diff --git a/crates/next-api/src/project.rs b/crates/next-api/src/project.rs index d3dd463d0e..f74b426864 100644 --- a/crates/next-api/src/project.rs +++ b/crates/next-api/src/project.rs @@ -45,7 +45,7 @@ use turbo_tasks::{ }; use turbo_tasks_env::{EnvMap, ProcessEnv}; use turbo_tasks_fs::{ - DiskFileSystem, FileContent, FileSystem, FileSystemPath, VirtualFileSystem, + DiskFileSystem, DiskWatcherConfig, FileContent, FileSystem, FileSystemPath, VirtualFileSystem, canonicalize_to_rcstr, invalidation, }; use turbo_unix_path::join_path; @@ -631,9 +631,7 @@ impl ProjectContainer { .read_strongly_consistent() .await?; if watch.enable { - project_fs - .start_watching_with_invalidation_reason(watch.poll_interval) - .await?; + project_fs.start_watching().await?; } else { project_fs.invalidate_with_reason(|path| invalidation::Initialize { // this path is just used for display purposes @@ -776,9 +774,7 @@ impl ProjectContainer { if !ReadRef::ptr_eq(&prev_project_fs, &project_fs) { if watch.enable { // TODO stop watching: prev_project_fs.stop_watching()?; - project_fs - .start_watching_with_invalidation_reason(watch.poll_interval) - .await?; + project_fs.start_watching().await?; } else { project_fs.invalidate_with_reason(|path| invalidation::Initialize { // this path is just used for display purposes @@ -1087,10 +1083,16 @@ impl Project { .unwrap() .into(); - Ok(DiskFileSystem::new_with_denied_paths( + Ok(DiskFileSystem::new_with_options( PROJECT_FILESYSTEM_NAME, *self.root_path, vec![denied_path, denied_profiles_path], + DiskWatcherConfig { + recursive_mode: None, + poll_interval: self.watch.poll_interval, + // the dev server reports these to the user + report_invalidation_reason: true, + }, )) } diff --git a/turbopack/crates/turbo-tasks-fs/examples/hash_directory.rs b/turbopack/crates/turbo-tasks-fs/examples/hash_directory.rs index ec4a63534b..3b39edf0ab 100644 --- a/turbopack/crates/turbo-tasks-fs/examples/hash_directory.rs +++ b/turbopack/crates/turbo-tasks-fs/examples/hash_directory.rs @@ -29,7 +29,7 @@ async fn main() -> Result<()> { Box::pin(async { let root = RcStr::from(current_dir().unwrap().to_str().unwrap()); let disk_fs = DiskFileSystem::new(rcstr!("project"), Vc::cell(root)); - disk_fs.await?.start_watching(None).await?; + disk_fs.await?.start_watching().await?; // Smart Pointer cast let fs: Vc> = Vc::upcast(disk_fs); diff --git a/turbopack/crates/turbo-tasks-fs/examples/hash_glob.rs b/turbopack/crates/turbo-tasks-fs/examples/hash_glob.rs index 3aa6492c2e..84cb1e0e38 100644 --- a/turbopack/crates/turbo-tasks-fs/examples/hash_glob.rs +++ b/turbopack/crates/turbo-tasks-fs/examples/hash_glob.rs @@ -30,7 +30,7 @@ async fn main() -> Result<()> { Box::pin(async { let root = RcStr::from(current_dir().unwrap().to_str().unwrap()); let disk_fs = DiskFileSystem::new(rcstr!("project"), Vc::cell(root)); - disk_fs.await?.start_watching(None).await?; + disk_fs.await?.start_watching().await?; // Smart Pointer cast let fs: Vc> = Vc::upcast(disk_fs); diff --git a/turbopack/crates/turbo-tasks-fs/src/disk.rs b/turbopack/crates/turbo-tasks-fs/src/disk.rs index af3245e398..2133641cff 100644 --- a/turbopack/crates/turbo-tasks-fs/src/disk.rs +++ b/turbopack/crates/turbo-tasks-fs/src/disk.rs @@ -9,7 +9,6 @@ use std::{ mem::take, path::{MAIN_SEPARATOR, Path, PathBuf}, sync::{Arc, LazyLock, Weak}, - time::Duration, }; use anyhow::{Context, Result, anyhow, bail}; @@ -42,7 +41,7 @@ use crate::{ mutex_map::MutexMap, path_map::OrderedPathMapExt, retry::{can_retry, retry_blocking, retry_blocking_custom}, - watcher::DiskWatcher, + watcher::{DiskWatcher, DiskWatcherConfig}, }; /// Validate the path, returning the valid path, a modified-but-now-valid path, or bailing with an @@ -445,11 +444,7 @@ impl DiskFileSystemInner { } #[tracing::instrument(level = "info", name = "start filesystem watching", skip_all, fields(path = %self.root))] - async fn start_watching_internal( - self: &Arc, - report_invalidation_reason: bool, - poll_interval: Option, - ) -> Result<()> { + async fn start_watching_internal(self: &Arc) -> Result<()> { let root_path = self.root_path().to_path_buf(); // create the directory for the filesystem on disk, if it doesn't exist @@ -458,8 +453,7 @@ impl DiskFileSystemInner { .concurrency_limited(&self.write_semaphore) .await?; - DiskWatcher::start_watching(self.clone(), report_invalidation_reason, poll_interval) - .await?; + DiskWatcher::start_watching(self.clone()).await?; Ok(()) } @@ -506,19 +500,8 @@ impl DiskFileSystem { .invalidate_path_and_children_with_reason(paths, reason); } - pub async fn start_watching(&self, poll_interval: Option) -> Result<()> { - self.inner - .start_watching_internal(false, poll_interval) - .await - } - - pub async fn start_watching_with_invalidation_reason( - &self, - poll_interval: Option, - ) -> Result<()> { - self.inner - .start_watching_internal(true, poll_interval) - .await + pub async fn start_watching(&self) -> Result<()> { + self.inner.start_watching_internal().await } pub async fn stop_watching(&self) { @@ -719,24 +702,32 @@ pub(crate) fn format_absolute_fs_path(path: &Path, name: &str, root_path: &Path) } impl DiskFileSystem { - /// Create a new instance of `DiskFileSystem`. `name` is a display name for the filesystem. This - /// should be unique. `root` is the [canonicalized][std::fs::canonicalize] root of the - /// filesystem. + /// Create a new instance of `DiskFileSystem`. + /// + /// `name` is a display name for the filesystem. This should be unique. `root` is the + /// [canonicalized][std::fs::canonicalize] root of the filesystem. /// /// This API does not canonicalize itself, as that requires IO operations (e.g. symlink /// resolution) which should (ideally) not be cached. pub fn new(name: RcStr, root: Vc) -> Vc { - Self::new_internal(name, root, Vec::new()) + Self::new_internal(name, root, Vec::new(), DiskWatcherConfig::default()) } - /// Create a new instance of `DiskFileSystem`. This is the same as [`DiskFileSystem::new`], but - /// with the option to mark certain paths as not allowed to be accessed or navigated to. + /// Create a new instance of `DiskFileSystem`. + /// + /// `name` is a display name for the filesystem. This should be unique. `root` is the + /// [canonicalized][std::fs::canonicalize] root of the filesystem. + /// + /// This API does not canonicalize itself, as that requires IO operations (e.g. symlink + /// resolution) which should (ideally) not be cached. /// - /// `denied_paths` must be normalized unix-style paths, non-empty and relative to the fs root. - pub fn new_with_denied_paths( + /// `denied_paths` is a list of paths that are not allowed to be accessed or navigated to. These + /// must be normalized unix-style paths, non-empty and relative to the fs root. + pub fn new_with_options( name: RcStr, root: Vc, denied_paths: Vec, + watcher_config: DiskWatcherConfig, ) -> Vc { for denied_path in &denied_paths { debug_assert!(!denied_path.is_empty(), "denied_path must not be empty"); @@ -745,7 +736,7 @@ impl DiskFileSystem { "denied_path must be normalized: {denied_path:?}" ); } - Self::new_internal(name, root, denied_paths) + Self::new_internal(name, root, denied_paths, watcher_config) } } @@ -756,6 +747,7 @@ impl DiskFileSystem { name: RcStr, root: Vc, denied_paths: Vec, + watcher_config: DiskWatcherConfig, ) -> Result> { let root = root.owned().await?; let instance = DiskFileSystem { @@ -768,7 +760,7 @@ impl DiskFileSystem { dir_invalidator_map: InvalidatorMap::new(), read_semaphore: create_read_semaphore(), write_semaphore: create_write_semaphore(), - watcher: DiskWatcher::new(), + watcher: DiskWatcher::new(watcher_config), denied_paths, turbo_tasks: turbo_tasks_weak(), tokio_handle: Handle::current(), diff --git a/turbopack/crates/turbo-tasks-fs/src/embed/dir.rs b/turbopack/crates/turbo-tasks-fs/src/embed/dir.rs index c291c95d4d..4143219277 100644 --- a/turbopack/crates/turbo-tasks-fs/src/embed/dir.rs +++ b/turbopack/crates/turbo-tasks-fs/src/embed/dir.rs @@ -19,7 +19,7 @@ pub async fn directory_from_relative_path( // development and the root directory is unlikely to move. let root = canonicalize_to_rcstr(Path::new(&*path))?; let disk_fs = DiskFileSystem::new(name, Vc::cell(root)); - disk_fs.await?.start_watching(None).await?; + disk_fs.await?.start_watching().await?; Ok(Vc::upcast(disk_fs)) } diff --git a/turbopack/crates/turbo-tasks-fs/src/lib.rs b/turbopack/crates/turbo-tasks-fs/src/lib.rs index efc0f4e1fe..d0773b250a 100644 --- a/turbopack/crates/turbo-tasks-fs/src/lib.rs +++ b/turbopack/crates/turbo-tasks-fs/src/lib.rs @@ -60,6 +60,7 @@ pub use crate::{ path::{FileSystemPath, FileSystemPathOption, RealPathResult, RealPathResultError, rebase}, read_glob::ReadGlobResult, virtual_fs::VirtualFileSystem, + watcher::{DiskWatcherConfig, DiskWatcherRecursiveMode}, windows::to_verbatim_with_case_folded_disk, }; diff --git a/turbopack/crates/turbo-tasks-fs/src/watcher/mod.rs b/turbopack/crates/turbo-tasks-fs/src/watcher/mod.rs index 7c733aca0e..40f9940333 100644 --- a/turbopack/crates/turbo-tasks-fs/src/watcher/mod.rs +++ b/turbopack/crates/turbo-tasks-fs/src/watcher/mod.rs @@ -15,10 +15,15 @@ use std::{ }; use anyhow::{Context, Result}; -use bincode::{Decode, Encode}; +use bincode::{ + Decode, Encode, + de::Decoder, + enc::Encoder, + error::{DecodeError, EncodeError}, +}; use bitflags::bitflags; use notify::{ - Config, EventKind, PollWatcher, RecommendedWatcher, RecursiveMode, Watcher, + Config, EventKind, PollWatcher, RecommendedWatcher, Watcher, event::{MetadataKind, ModifyKind, RenameMode}, }; use rustc_hash::{FxHashMap, FxHashSet}; @@ -26,8 +31,8 @@ use tokio::sync::{RwLock, RwLockWriteGuard}; use tracing::instrument; use turbo_rcstr::RcStr; use turbo_tasks::{ - FxIndexSet, InvalidationReason, InvalidationReasonKind, Invalidator, TurboTasksApi, - spawn_thread, util::StaticOrArc, + FxIndexSet, InvalidationReason, InvalidationReasonKind, Invalidator, NonLocalValue, TaskInput, + TurboTasksApi, spawn_thread, trace::TraceRawVcs, util::StaticOrArc, }; use crate::{ @@ -38,33 +43,109 @@ use crate::{ watcher::fs_api::DiskFileSystemWatcherApi, }; -static WATCH_RECURSIVE_MODE: LazyLock = LazyLock::new(|| { - match env::var("TURBO_TASKS_FORCE_WATCH_MODE").as_deref() { - Ok("recursive") => { - return RecursiveMode::Recursive; - } - Ok("nonrecursive") => { - return RecursiveMode::NonRecursive; - } +/// Overrides [`DiskWatcherConfig::recursive_mode`]. Users shouldn't need to set this, this is +/// intended only for debugging purposes. +static FORCED_WATCH_RECURSIVE_MODE: LazyLock> = LazyLock::new( + || match env::var("TURBO_TASKS_FORCE_WATCH_MODE").as_deref() { + Ok("recursive") => Some(DiskWatcherRecursiveMode::Recursive), + Ok("nonrecursive") => Some(DiskWatcherRecursiveMode::NonRecursive), Ok(_) => { eprintln!( "unsupported `TURBO_TASKS_FORCE_WATCH_MODE`, must be `recursive` or `nonrecursive`" ); + None + } + _ => None, + }, +); + +#[derive( + Clone, Copy, Debug, Default, Eq, PartialEq, Hash, TraceRawVcs, NonLocalValue, Encode, Decode, +)] +pub struct DiskWatcherConfig { + /// Whether to let the [`notify::Watcher`] recurse into subdirectories itself, or to track and + /// watch each directory we care about ourselves. + /// + /// [`None`] picks a default based on the platform and [`Self::poll_interval`], which is + /// normally what you want. + /// + /// The `TURBO_TASKS_FORCE_WATCH_MODE` environment variable will override this configuration + /// value (intended for debugging purposes). + pub recursive_mode: Option, + /// Poll the filesystem at this interval instead of using the platform's native file watching, + /// for cases where native watching doesn't work (e.g. some Docker setups). This is slow and + /// inefficient, it should only be used as a last resort. + /// + /// [`None`] disables polling, using the platform's native watcher ([`RecommendedWatcher`]) + /// instead of [`PollWatcher`]. + pub poll_interval: Option, + /// Attach an [`InvalidationReason`] to every invalidation the watcher causes ([`WatchStart`], + /// [`WatchChange`], or [`InvalidateRescan`]), so that it can be reported to the user. + /// + /// This costs an extra allocation per invalidated path, so it's only worth enabling when + /// something actually consumes the reasons. + pub report_invalidation_reason: bool, +} + +impl TaskInput for DiskWatcherConfig { + fn is_transient(&self) -> bool { + false + } +} + +/// Equivalent to [`notify::RecursiveMode`], but implements traits needed by [`turbo_tasks`]. +/// +/// When using [`Self::Recursive`], [`notify::Watcher`] will recursively track all contents +/// of the filesystem root. This should only be used on platforms with efficient recursive watcher +/// implementations (i.e. macOS and Windows). +/// +/// When using [`Self::NonRecursive`], we only track previously read files and their parent +/// directories. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, TraceRawVcs, NonLocalValue, Encode, Decode)] +pub enum DiskWatcherRecursiveMode { + Recursive, + NonRecursive, +} + +impl From for notify::RecursiveMode { + fn from(value: DiskWatcherRecursiveMode) -> Self { + match value { + DiskWatcherRecursiveMode::Recursive => notify::RecursiveMode::Recursive, + DiskWatcherRecursiveMode::NonRecursive => notify::RecursiveMode::NonRecursive, } - _ => {} } - if cfg!(any(target_os = "macos", target_os = "windows")) { - // these platforms have efficient recursive watchers, it's best to track the entire - // directory and filter events to the files we care about - RecursiveMode::Recursive - } else { - // inotify on linux is non-recursive, so notify-rs's implementation is inefficient, it's - // better for us to just track it ourselves and only watch the files we know we care about +} + +impl DiskWatcherConfig { + /// Resolves [`Self::recursive_mode`], falling back to a default based on + /// [`Self::poll_interval`] and the platform. + fn resolve_recursive_mode(&self) -> DiskWatcherRecursiveMode { + // macOS and Windows have efficient recursive watchers, so it's best to track the entire + // directory and filter events to the files we care about. inotify on Linux is + // non-recursive, so notify-rs's implementation is inefficient; better for us to track it + // ourselves and only watch the directories we know we care about. // - // See: https://github.com/vercel/turborepo/pull/4100 - RecursiveMode::NonRecursive + // See: + let platform_has_efficient_recursive_watcher = + cfg!(any(target_os = "macos", target_os = "windows")); + + // the env var is a debugging escape hatch, so it wins over everything else + if let Some(forced) = *FORCED_WATCH_RECURSIVE_MODE { + forced + } else if let Some(recursive_mode) = self.recursive_mode { + recursive_mode + } else if self.poll_interval.is_some() { + // `PollWatcher` implements recursive watching by walking the entire subtree on every + // poll, so watching the fs root recursively would stat every file in the project each + // interval. Watching non-recursively keeps each poll to the directories we've read. + DiskWatcherRecursiveMode::NonRecursive + } else if platform_has_efficient_recursive_watcher { + DiskWatcherRecursiveMode::Recursive + } else { + DiskWatcherRecursiveMode::NonRecursive + } } -}); +} /// How long to extend an invalidation batch by when receiving new events, before flushing. This /// reduces invalidations if the same file or directory is modified many times. @@ -75,35 +156,45 @@ const BATCH_DELAY: Duration = Duration::from_millis(10); #[cfg(not(target_os = "linux"))] const BATCH_DELAY: Duration = Duration::from_millis(1); -#[derive(Encode, Decode)] pub(crate) struct DiskWatcher { - #[bincode(skip)] state: State, + config: DiskWatcherConfig, +} + +/// Only [`Self::config`] is serialized: a decoded [`DiskWatcher`] is always stopped. +impl Encode for DiskWatcher { + fn encode(&self, encoder: &mut E) -> Result<(), EncodeError> { + self.config.encode(encoder) + } } +impl Decode for DiskWatcher { + fn decode>(decoder: &mut D) -> Result { + Ok(Self::new(DiskWatcherConfig::decode(decoder)?)) + } +} +bincode::impl_borrow_decode!(DiskWatcher); + enum State { // Note: Information about if we're a recursive or non-recursive watcher must live outside the - // `RwLock` to allow us to quickly bail out on calls to `ensure_watched`. + // `RwLock` to allow us to quickly bail out before calling functions in + // `non_recursive_helpers`. Recursive(RwLock), NonRecursive(RwLock), } -impl Default for State { - fn default() -> Self { - State::new_stopped() - } -} - enum StateWriteGuard<'a> { Recursive(RwLockWriteGuard<'a, RecursiveState>), NonRecursive(RwLockWriteGuard<'a, NonRecursiveState>), } impl State { - fn new_stopped() -> Self { - match *WATCH_RECURSIVE_MODE { - RecursiveMode::Recursive => Self::Recursive(RwLock::new(RecursiveState::Stopped)), - RecursiveMode::NonRecursive => { + fn new_stopped(recursive_mode: DiskWatcherRecursiveMode) -> Self { + match recursive_mode { + DiskWatcherRecursiveMode::Recursive => { + Self::Recursive(RwLock::new(RecursiveState::Stopped)) + } + DiskWatcherRecursiveMode::NonRecursive => { Self::NonRecursive(RwLock::new(NonRecursiveState::Stopped)) } } @@ -116,16 +207,16 @@ impl State { } } - fn recursive_mode(&self) -> RecursiveMode { + fn recursive_mode(&self) -> DiskWatcherRecursiveMode { match self { - Self::Recursive(_) => RecursiveMode::Recursive, - Self::NonRecursive(_) => RecursiveMode::NonRecursive, + Self::Recursive(_) => DiskWatcherRecursiveMode::Recursive, + Self::NonRecursive(_) => DiskWatcherRecursiveMode::NonRecursive, } } } -/// Used by when [`WATCH_RECURSIVE_MODE`] is [`RecursiveMode::Recursive`] (default on macOS and -/// Windows). +/// Used when [`DiskWatcherConfig::recursive_mode`] returns [`RecursiveMode::Recursive`] (default on +/// macOS and Windows when not polling). enum RecursiveState { /// Used when [`DiskWatcher::start_watching`] hasn't been called yet or after /// [`DiskWatcher::stop_watching`] is called. @@ -136,7 +227,8 @@ enum RecursiveState { }, } -/// Used by when [`WATCH_RECURSIVE_MODE`] is [`RecursiveMode::NonRecursive`] (default on Linux). +/// Used when [`DiskWatcherConfig::recursive_mode`] returns [`RecursiveMode::NonRecursive`] (default +/// on Linux, and everywhere when polling). enum NonRecursiveState { /// Used when [`DiskWatcher::start_watching`] hasn't been called yet or after /// [`DiskWatcher::stop_watching`] is called. @@ -164,7 +256,7 @@ enum NotifyWatcher { } impl NotifyWatcher { - fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> notify::Result<()> { + fn watch(&mut self, path: &Path, recursive_mode: notify::RecursiveMode) -> notify::Result<()> { match self { Self::Recommended(watcher) => watcher.watch(path, recursive_mode), Self::Polling(watcher) => watcher.watch(path, recursive_mode), @@ -291,7 +383,7 @@ mod non_recursive_helpers { ) -> Result<()> { debug_assert_ne!(dir_path, root_path); - match notify_watcher.watch(dir_path, RecursiveMode::NonRecursive) { + match notify_watcher.watch(dir_path, notify::RecursiveMode::NonRecursive) { Ok(()) | Err(notify::Error { // The path was probably deleted before we could process the event, but the parent @@ -358,17 +450,14 @@ mod non_recursive_helpers { } impl DiskWatcher { - pub fn new() -> Self { + pub fn new(config: DiskWatcherConfig) -> Self { Self { - state: State::new_stopped(), + state: State::new_stopped(config.resolve_recursive_mode()), + config, } } - pub async fn start_watching( - fs: Arc, - report_invalidation_reason: bool, - poll_interval: Option, - ) -> Result<()> { + pub async fn start_watching(fs: Arc) -> Result<()> { let watcher: &Self = fs.watcher(); let state_guard = watcher.state.write().await; @@ -392,7 +481,7 @@ impl DiskWatcher { // turbo-tasks-fs let config = config.with_follow_symlinks(false); - let mut notify_watcher = if let Some(poll_interval) = poll_interval { + let mut notify_watcher = if let Some(poll_interval) = watcher.config.poll_interval { let config = config.with_poll_interval(poll_interval); NotifyWatcher::Polling(PollWatcher::new(tx, config)?) } else { @@ -402,17 +491,16 @@ impl DiskWatcher { // TOCTOU: we must watch `root_path` before calling any invalidators and setting up the // watchers in their associated functions let root_path = fs.root_path(); - let recursive_mode = match state_guard { - StateWriteGuard::Recursive(_) => RecursiveMode::Recursive, - StateWriteGuard::NonRecursive(_) => RecursiveMode::NonRecursive, - }; - notify_watcher.watch(root_path, recursive_mode)?; + notify_watcher.watch( + root_path, + notify::RecursiveMode::from(watcher.state.recursive_mode()), + )?; // We need to invalidate all reads or writes that happened before watching. As a // side-effect, this will call `ensure_watched` again, setting up any watchers needed. // // Best is to start_watching before starting to read - if report_invalidation_reason { + if watcher.config.report_invalidation_reason { let name = fs.name().clone(); fs.invalidate_all_with_reason(|path| WatchStart { name: name.clone(), @@ -425,7 +513,7 @@ impl DiskWatcher { spawn_thread({ let fs = fs.clone(); - move || Self::watch_thread(fs, rx, report_invalidation_reason) + move || Self::watch_thread(fs, rx) }); // Updating `self.state` is done last. If we panic while setting up the watcher, it'll @@ -463,10 +551,13 @@ impl DiskWatcher { fn watch_thread( fs: Arc, rx: Receiver>, - report_invalidation_reason: bool, ) { let watcher: &Self = fs.watcher(); - let mut batch = BatchedInvalidations::new(watcher.state.recursive_mode()); + let report_invalidation_reason = watcher.config.report_invalidation_reason; + let mut batch = BatchedInvalidations::new( + watcher.state.recursive_mode(), + watcher.config.poll_interval.is_some(), + ); 'outer: loop { let mut deadline: Option = None; @@ -644,16 +735,47 @@ struct BatchedInvalidations { paths: FxHashMap, InvalidationFlags>, /// See [`Self::new_paths`]). Stored as [`None`] in non-recursive mode. new_paths: Option>>, + /// Whether events are coming from [`PollWatcher`] instead of [`RecommendedWatcher`], which + /// changes how a file content change is reported. See [`Self::is_content_change`]. + polling: bool, } impl BatchedInvalidations { - fn new(recursive_mode: RecursiveMode) -> Self { + fn new(recursive_mode: DiskWatcherRecursiveMode, polling: bool) -> Self { Self { paths: FxHashMap::default(), new_paths: match recursive_mode { - RecursiveMode::NonRecursive => Some(FxHashSet::default()), - RecursiveMode::Recursive => None, + DiskWatcherRecursiveMode::NonRecursive => Some(FxHashSet::default()), + DiskWatcherRecursiveMode::Recursive => None, }, + polling, + } + } + + /// Whether a [`ModifyKind::Metadata`] event means the file's *contents* changed. + /// + /// Some backends don't report content changes as [`ModifyKind::Data`] at all, so we have to + /// treat one specific metadata change per backend as a content change. Accepting these + /// unconditionally would mean invalidating on every `chmod`/`touch` on the backends that do + /// report `Data` properly. + fn is_content_change(&self, kind: MetadataKind) -> bool { + match kind { + // `PollWatcher` detects changes by comparing mtimes, so a content change surfaces as a + // write-time change. It only emits `Data` when `Config::with_compare_contents` is + // enabled, which we don't do because hashing every watched file is too expensive. + MetadataKind::WriteTime => self.polling, + // fsevents does not always emit `kFSEventStreamEventFlagItemModified` for a content + // change; sometimes it only emits `kFSEventStreamEventFlagItemInodeMetaMod`, which + // notify maps to `MetadataKind::Any`. This causes redundant invalidations, but it's the + // only way to reliably detect content changes there. Fix for PACK-2437. + // + // libuv does the same thing to trigger `UV_CHANGES`: + // https://github.com/libuv/libuv/commit/73cf3600d75a5884b890a1a94048b8f3f9c66876 + // + // inotify and ReadDirectoryChangesW both report content changes on their own, so + // `MetadataKind::Any` there only ever means an actual attribute change. + MetadataKind::Any => cfg!(target_os = "macos"), + _ => false, } } @@ -700,18 +822,14 @@ impl BatchedInvalidations { return false; } match event.kind { - // [NOTE] Observing `ModifyKind::Metadata(MetadataKind::Any)` is not a mistake, fix for - // PACK-2437. - // In here explicitly subscribes to the `ModifyKind::Data` which indicates file content - // changes - in case of fsevents backend, this is `kFSEventStreamEventFlagItemModified`. - // Also meanwhile we subscribe to `ModifyKind::Metadata` as well. - // This is due to in some cases fsevents does not emit explicit - // `kFSEventStreamEventFlagItemModified` kernel events, but only emits - // `kFSEventStreamEventFlagItemInodeMetaMod`. While this could cause redundant - // invalidation, it's the way to reliably detect file content changes. - // ref other implementation, i.e libuv does same thing to trigger `UV_CHANGES` - // https://github.com/libuv/libuv/commit/73cf3600d75a5884b890a1a94048b8f3f9c66876 - EventKind::Modify(ModifyKind::Data(_) | ModifyKind::Metadata(MetadataKind::Any)) => { + EventKind::Modify(ModifyKind::Data(_)) => { + for path in paths { + self.mark(path.into_boxed_path(), InvalidationFlags::PATH); + } + true + } + // Some backends (fsevents, polling) can report metadata events for file content changes + EventKind::Modify(ModifyKind::Metadata(kind)) if self.is_content_change(kind) => { for path in paths { self.mark(path.into_boxed_path(), InvalidationFlags::PATH); } diff --git a/turbopack/crates/turbo-tasks-fuzz/src/fs_watcher.rs b/turbopack/crates/turbo-tasks-fuzz/src/fs_watcher.rs index 826ae5e4dd..212efda935 100644 --- a/turbopack/crates/turbo-tasks-fuzz/src/fs_watcher.rs +++ b/turbopack/crates/turbo-tasks-fuzz/src/fs_watcher.rs @@ -129,7 +129,7 @@ pub async fn run(args: FsWatcher) -> anyhow::Result<()> { }; if !args.start_watching_late { - project_fs.await?.start_watching(None).await?; + project_fs.await?.start_watching().await?; } let symlink_count = if args.symlinks.is_some() { @@ -175,7 +175,7 @@ pub async fn run(args: FsWatcher) -> anyhow::Result<()> { invalidations.0.lock().unwrap().clear(); if args.start_watching_late { - project_fs.await?.start_watching(None).await?; + project_fs.await?.start_watching().await?; } let mut rand_buf = [0; 16]; diff --git a/turbopack/crates/turbopack-cli/src/util.rs b/turbopack/crates/turbopack-cli/src/util.rs index d14b300dac..df54a1db37 100644 --- a/turbopack/crates/turbopack-cli/src/util.rs +++ b/turbopack/crates/turbopack-cli/src/util.rs @@ -4,7 +4,7 @@ use anyhow::{Context, Result}; use bincode::{Decode, Encode}; use turbo_rcstr::{RcStr, rcstr}; use turbo_tasks::{Vc, trace::TraceRawVcs}; -use turbo_tasks_fs::{DiskFileSystem, FileSystem, canonicalize_to_rcstr}; +use turbo_tasks_fs::{DiskFileSystem, DiskWatcherConfig, FileSystem, canonicalize_to_rcstr}; #[turbo_tasks::task_input] #[derive(Clone, Debug, Hash, PartialEq, Eq, TraceRawVcs, Encode, Decode)] @@ -56,13 +56,14 @@ pub async fn project_fs( watch: bool, denied_root_path: RcStr, ) -> Result>> { - let disk_fs = DiskFileSystem::new_with_denied_paths( + let disk_fs = DiskFileSystem::new_with_options( rcstr!("project"), Vc::cell(project_dir), vec![denied_root_path], + DiskWatcherConfig::default(), ); if watch { - disk_fs.await?.start_watching(None).await?; + disk_fs.await?.start_watching().await?; } Ok(Vc::upcast(disk_fs)) } diff --git a/turbopack/crates/turbopack/examples/turbopack.rs b/turbopack/crates/turbopack/examples/turbopack.rs index ad4209bab0..256e0f31f2 100644 --- a/turbopack/crates/turbopack/examples/turbopack.rs +++ b/turbopack/crates/turbopack/examples/turbopack.rs @@ -37,7 +37,7 @@ async fn main() -> Result<()> { Box::pin(async { let root: RcStr = current_dir().unwrap().to_str().unwrap().into(); let disk_fs = DiskFileSystem::new(PROJECT_FILESYSTEM_NAME, Vc::cell(root)); - disk_fs.await?.start_watching(None).await?; + disk_fs.await?.start_watching().await?; // Smart Pointer cast let fs: Vc> = Vc::upcast(disk_fs);