1use crate::{ProjectEntryId, RemoveOptions};
   2
   3use super::{
   4    fs::{self, Fs},
   5    ignore::IgnoreStack,
   6    DiagnosticSummary,
   7};
   8use ::ignore::gitignore::{Gitignore, GitignoreBuilder};
   9use anyhow::{anyhow, Context, Result};
  10use client::{proto, Client, TypedEnvelope};
  11use clock::ReplicaId;
  12use collections::HashMap;
  13use futures::{
  14    channel::{
  15        mpsc::{self, UnboundedSender},
  16        oneshot,
  17    },
  18    Stream, StreamExt,
  19};
  20use fuzzy::CharBag;
  21use gpui::{
  22    executor, AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext,
  23    Task,
  24};
  25use language::{
  26    proto::{deserialize_version, serialize_version},
  27    Buffer, DiagnosticEntry, PointUtf16, Rope,
  28};
  29use lazy_static::lazy_static;
  30use parking_lot::Mutex;
  31use postage::{
  32    prelude::{Sink as _, Stream as _},
  33    watch,
  34};
  35use smol::channel::{self, Sender};
  36use std::{
  37    any::Any,
  38    cmp::{self, Ordering},
  39    convert::TryFrom,
  40    ffi::{OsStr, OsString},
  41    fmt,
  42    future::Future,
  43    mem,
  44    ops::{Deref, DerefMut},
  45    os::unix::prelude::{OsStrExt, OsStringExt},
  46    path::{Path, PathBuf},
  47    sync::{atomic::AtomicUsize, Arc},
  48    time::{Duration, SystemTime},
  49};
  50use sum_tree::{Bias, Edit, SeekTarget, SumTree, TreeMap};
  51use util::{ResultExt, TryFutureExt};
  52
  53lazy_static! {
  54    static ref GITIGNORE: &'static OsStr = OsStr::new(".gitignore");
  55}
  56
  57#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
  58pub struct WorktreeId(usize);
  59
  60pub enum Worktree {
  61    Local(LocalWorktree),
  62    Remote(RemoteWorktree),
  63}
  64
  65pub struct LocalWorktree {
  66    snapshot: LocalSnapshot,
  67    background_snapshot: Arc<Mutex<LocalSnapshot>>,
  68    last_scan_state_rx: watch::Receiver<ScanState>,
  69    _background_scanner_task: Option<Task<()>>,
  70    poll_task: Option<Task<()>>,
  71    registration: Registration,
  72    share: Option<ShareState>,
  73    diagnostics: HashMap<Arc<Path>, Vec<DiagnosticEntry<PointUtf16>>>,
  74    diagnostic_summaries: TreeMap<PathKey, DiagnosticSummary>,
  75    client: Arc<Client>,
  76    fs: Arc<dyn Fs>,
  77    visible: bool,
  78}
  79
  80pub struct RemoteWorktree {
  81    pub snapshot: Snapshot,
  82    pub(crate) background_snapshot: Arc<Mutex<Snapshot>>,
  83    project_id: u64,
  84    client: Arc<Client>,
  85    updates_tx: UnboundedSender<proto::UpdateWorktree>,
  86    last_scan_id_rx: watch::Receiver<usize>,
  87    replica_id: ReplicaId,
  88    diagnostic_summaries: TreeMap<PathKey, DiagnosticSummary>,
  89    visible: bool,
  90}
  91
  92#[derive(Clone)]
  93pub struct Snapshot {
  94    id: WorktreeId,
  95    root_name: String,
  96    root_char_bag: CharBag,
  97    entries_by_path: SumTree<Entry>,
  98    entries_by_id: SumTree<PathEntry>,
  99    scan_id: usize,
 100}
 101
 102#[derive(Clone)]
 103pub struct LocalSnapshot {
 104    abs_path: Arc<Path>,
 105    ignores: HashMap<Arc<Path>, (Arc<Gitignore>, usize)>,
 106    removed_entry_ids: HashMap<u64, ProjectEntryId>,
 107    next_entry_id: Arc<AtomicUsize>,
 108    snapshot: Snapshot,
 109}
 110
 111impl Deref for LocalSnapshot {
 112    type Target = Snapshot;
 113
 114    fn deref(&self) -> &Self::Target {
 115        &self.snapshot
 116    }
 117}
 118
 119impl DerefMut for LocalSnapshot {
 120    fn deref_mut(&mut self) -> &mut Self::Target {
 121        &mut self.snapshot
 122    }
 123}
 124
 125#[derive(Clone, Debug)]
 126enum ScanState {
 127    Idle,
 128    Scanning,
 129    Err(Arc<anyhow::Error>),
 130}
 131
 132#[derive(Debug, Eq, PartialEq)]
 133enum Registration {
 134    None,
 135    Pending,
 136    Done { project_id: u64 },
 137}
 138
 139struct ShareState {
 140    project_id: u64,
 141    snapshots_tx: Sender<LocalSnapshot>,
 142    _maintain_remote_snapshot: Option<Task<Option<()>>>,
 143}
 144
 145pub enum Event {
 146    UpdatedEntries,
 147}
 148
 149impl Entity for Worktree {
 150    type Event = Event;
 151
 152    fn release(&mut self, _: &mut MutableAppContext) {
 153        if let Some(worktree) = self.as_local_mut() {
 154            if let Registration::Done { project_id } = worktree.registration {
 155                let client = worktree.client.clone();
 156                let unregister_message = proto::UnregisterWorktree {
 157                    project_id,
 158                    worktree_id: worktree.id().to_proto(),
 159                };
 160                client.send(unregister_message).log_err();
 161            }
 162        }
 163    }
 164}
 165
 166impl Worktree {
 167    pub async fn local(
 168        client: Arc<Client>,
 169        path: impl Into<Arc<Path>>,
 170        visible: bool,
 171        fs: Arc<dyn Fs>,
 172        next_entry_id: Arc<AtomicUsize>,
 173        cx: &mut AsyncAppContext,
 174    ) -> Result<ModelHandle<Self>> {
 175        let (tree, scan_states_tx) =
 176            LocalWorktree::new(client, path, visible, fs.clone(), next_entry_id, cx).await?;
 177        tree.update(cx, |tree, cx| {
 178            let tree = tree.as_local_mut().unwrap();
 179            let abs_path = tree.abs_path().clone();
 180            let background_snapshot = tree.background_snapshot.clone();
 181            let background = cx.background().clone();
 182            tree._background_scanner_task = Some(cx.background().spawn(async move {
 183                let events = fs.watch(&abs_path, Duration::from_millis(100)).await;
 184                let scanner =
 185                    BackgroundScanner::new(background_snapshot, scan_states_tx, fs, background);
 186                scanner.run(events).await;
 187            }));
 188        });
 189        Ok(tree)
 190    }
 191
 192    pub fn remote(
 193        project_remote_id: u64,
 194        replica_id: ReplicaId,
 195        worktree: proto::Worktree,
 196        client: Arc<Client>,
 197        cx: &mut MutableAppContext,
 198    ) -> (ModelHandle<Self>, Task<()>) {
 199        let remote_id = worktree.id;
 200        let root_char_bag: CharBag = worktree
 201            .root_name
 202            .chars()
 203            .map(|c| c.to_ascii_lowercase())
 204            .collect();
 205        let root_name = worktree.root_name.clone();
 206        let visible = worktree.visible;
 207        let snapshot = Snapshot {
 208            id: WorktreeId(remote_id as usize),
 209            root_name,
 210            root_char_bag,
 211            entries_by_path: Default::default(),
 212            entries_by_id: Default::default(),
 213            scan_id: worktree.scan_id as usize,
 214        };
 215
 216        let (updates_tx, mut updates_rx) = mpsc::unbounded();
 217        let background_snapshot = Arc::new(Mutex::new(snapshot.clone()));
 218        let (mut snapshot_updated_tx, mut snapshot_updated_rx) = watch::channel();
 219        let (mut last_scan_id_tx, last_scan_id_rx) = watch::channel_with(worktree.scan_id as usize);
 220        let worktree_handle = cx.add_model(|_: &mut ModelContext<Worktree>| {
 221            Worktree::Remote(RemoteWorktree {
 222                project_id: project_remote_id,
 223                replica_id,
 224                snapshot: snapshot.clone(),
 225                background_snapshot: background_snapshot.clone(),
 226                updates_tx,
 227                last_scan_id_rx,
 228                client: client.clone(),
 229                diagnostic_summaries: TreeMap::from_ordered_entries(
 230                    worktree.diagnostic_summaries.into_iter().map(|summary| {
 231                        (
 232                            PathKey(PathBuf::from(summary.path).into()),
 233                            DiagnosticSummary {
 234                                error_count: summary.error_count as usize,
 235                                warning_count: summary.warning_count as usize,
 236                            },
 237                        )
 238                    }),
 239                ),
 240                visible,
 241            })
 242        });
 243
 244        let deserialize_task = cx.spawn({
 245            let worktree_handle = worktree_handle.clone();
 246            |cx| async move {
 247                let (entries_by_path, entries_by_id) = cx
 248                    .background()
 249                    .spawn(async move {
 250                        let mut entries_by_path_edits = Vec::new();
 251                        let mut entries_by_id_edits = Vec::new();
 252                        for entry in worktree.entries {
 253                            match Entry::try_from((&root_char_bag, entry)) {
 254                                Ok(entry) => {
 255                                    entries_by_id_edits.push(Edit::Insert(PathEntry {
 256                                        id: entry.id,
 257                                        path: entry.path.clone(),
 258                                        is_ignored: entry.is_ignored,
 259                                        scan_id: 0,
 260                                    }));
 261                                    entries_by_path_edits.push(Edit::Insert(entry));
 262                                }
 263                                Err(err) => log::warn!("error for remote worktree entry {:?}", err),
 264                            }
 265                        }
 266
 267                        let mut entries_by_path = SumTree::new();
 268                        let mut entries_by_id = SumTree::new();
 269                        entries_by_path.edit(entries_by_path_edits, &());
 270                        entries_by_id.edit(entries_by_id_edits, &());
 271
 272                        (entries_by_path, entries_by_id)
 273                    })
 274                    .await;
 275
 276                {
 277                    let mut snapshot = background_snapshot.lock();
 278                    snapshot.entries_by_path = entries_by_path;
 279                    snapshot.entries_by_id = entries_by_id;
 280                    snapshot_updated_tx.send(()).await.ok();
 281                }
 282
 283                cx.background()
 284                    .spawn(async move {
 285                        while let Some(update) = updates_rx.next().await {
 286                            if let Err(error) =
 287                                background_snapshot.lock().apply_remote_update(update)
 288                            {
 289                                log::error!("error applying worktree update: {}", error);
 290                            }
 291                            snapshot_updated_tx.send(()).await.ok();
 292                        }
 293                    })
 294                    .detach();
 295
 296                cx.spawn(|mut cx| {
 297                    let this = worktree_handle.downgrade();
 298                    async move {
 299                        while let Some(_) = snapshot_updated_rx.recv().await {
 300                            if let Some(this) = this.upgrade(&cx) {
 301                                this.update(&mut cx, |this, cx| {
 302                                    this.poll_snapshot(cx);
 303                                    let this = this.as_remote_mut().unwrap();
 304                                    *last_scan_id_tx.borrow_mut() = this.snapshot.scan_id;
 305                                });
 306                            } else {
 307                                break;
 308                            }
 309                        }
 310                    }
 311                })
 312                .detach();
 313            }
 314        });
 315        (worktree_handle, deserialize_task)
 316    }
 317
 318    pub fn as_local(&self) -> Option<&LocalWorktree> {
 319        if let Worktree::Local(worktree) = self {
 320            Some(worktree)
 321        } else {
 322            None
 323        }
 324    }
 325
 326    pub fn as_remote(&self) -> Option<&RemoteWorktree> {
 327        if let Worktree::Remote(worktree) = self {
 328            Some(worktree)
 329        } else {
 330            None
 331        }
 332    }
 333
 334    pub fn as_local_mut(&mut self) -> Option<&mut LocalWorktree> {
 335        if let Worktree::Local(worktree) = self {
 336            Some(worktree)
 337        } else {
 338            None
 339        }
 340    }
 341
 342    pub fn as_remote_mut(&mut self) -> Option<&mut RemoteWorktree> {
 343        if let Worktree::Remote(worktree) = self {
 344            Some(worktree)
 345        } else {
 346            None
 347        }
 348    }
 349
 350    pub fn is_local(&self) -> bool {
 351        matches!(self, Worktree::Local(_))
 352    }
 353
 354    pub fn is_remote(&self) -> bool {
 355        !self.is_local()
 356    }
 357
 358    pub fn snapshot(&self) -> Snapshot {
 359        match self {
 360            Worktree::Local(worktree) => worktree.snapshot().snapshot,
 361            Worktree::Remote(worktree) => worktree.snapshot(),
 362        }
 363    }
 364
 365    pub fn scan_id(&self) -> usize {
 366        match self {
 367            Worktree::Local(worktree) => worktree.snapshot.scan_id,
 368            Worktree::Remote(worktree) => worktree.snapshot.scan_id,
 369        }
 370    }
 371
 372    pub fn is_visible(&self) -> bool {
 373        match self {
 374            Worktree::Local(worktree) => worktree.visible,
 375            Worktree::Remote(worktree) => worktree.visible,
 376        }
 377    }
 378
 379    pub fn replica_id(&self) -> ReplicaId {
 380        match self {
 381            Worktree::Local(_) => 0,
 382            Worktree::Remote(worktree) => worktree.replica_id,
 383        }
 384    }
 385
 386    pub fn diagnostic_summaries<'a>(
 387        &'a self,
 388    ) -> impl Iterator<Item = (Arc<Path>, DiagnosticSummary)> + 'a {
 389        match self {
 390            Worktree::Local(worktree) => &worktree.diagnostic_summaries,
 391            Worktree::Remote(worktree) => &worktree.diagnostic_summaries,
 392        }
 393        .iter()
 394        .map(|(path, summary)| (path.0.clone(), summary.clone()))
 395    }
 396
 397    fn poll_snapshot(&mut self, cx: &mut ModelContext<Self>) {
 398        match self {
 399            Self::Local(worktree) => {
 400                let is_fake_fs = worktree.fs.is_fake();
 401                worktree.snapshot = worktree.background_snapshot.lock().clone();
 402                if worktree.is_scanning() {
 403                    if worktree.poll_task.is_none() {
 404                        worktree.poll_task = Some(cx.spawn_weak(|this, mut cx| async move {
 405                            if is_fake_fs {
 406                                #[cfg(any(test, feature = "test-support"))]
 407                                cx.background().simulate_random_delay().await;
 408                            } else {
 409                                smol::Timer::after(Duration::from_millis(100)).await;
 410                            }
 411                            if let Some(this) = this.upgrade(&cx) {
 412                                this.update(&mut cx, |this, cx| {
 413                                    this.as_local_mut().unwrap().poll_task = None;
 414                                    this.poll_snapshot(cx);
 415                                });
 416                            }
 417                        }));
 418                    }
 419                } else {
 420                    worktree.poll_task.take();
 421                    cx.emit(Event::UpdatedEntries);
 422                }
 423            }
 424            Self::Remote(worktree) => {
 425                worktree.snapshot = worktree.background_snapshot.lock().clone();
 426                cx.emit(Event::UpdatedEntries);
 427            }
 428        };
 429
 430        cx.notify();
 431    }
 432}
 433
 434impl LocalWorktree {
 435    async fn new(
 436        client: Arc<Client>,
 437        path: impl Into<Arc<Path>>,
 438        visible: bool,
 439        fs: Arc<dyn Fs>,
 440        next_entry_id: Arc<AtomicUsize>,
 441        cx: &mut AsyncAppContext,
 442    ) -> Result<(ModelHandle<Worktree>, UnboundedSender<ScanState>)> {
 443        let abs_path = path.into();
 444        let path: Arc<Path> = Arc::from(Path::new(""));
 445
 446        // After determining whether the root entry is a file or a directory, populate the
 447        // snapshot's "root name", which will be used for the purpose of fuzzy matching.
 448        let root_name = abs_path
 449            .file_name()
 450            .map_or(String::new(), |f| f.to_string_lossy().to_string());
 451        let root_char_bag = root_name.chars().map(|c| c.to_ascii_lowercase()).collect();
 452        let metadata = fs
 453            .metadata(&abs_path)
 454            .await
 455            .context("failed to stat worktree path")?;
 456
 457        let (scan_states_tx, mut scan_states_rx) = mpsc::unbounded();
 458        let (mut last_scan_state_tx, last_scan_state_rx) = watch::channel_with(ScanState::Scanning);
 459        let tree = cx.add_model(move |cx: &mut ModelContext<Worktree>| {
 460            let mut snapshot = LocalSnapshot {
 461                abs_path,
 462                ignores: Default::default(),
 463                removed_entry_ids: Default::default(),
 464                next_entry_id,
 465                snapshot: Snapshot {
 466                    id: WorktreeId::from_usize(cx.model_id()),
 467                    root_name: root_name.clone(),
 468                    root_char_bag,
 469                    entries_by_path: Default::default(),
 470                    entries_by_id: Default::default(),
 471                    scan_id: 0,
 472                },
 473            };
 474            if let Some(metadata) = metadata {
 475                let entry = Entry::new(
 476                    path.into(),
 477                    &metadata,
 478                    &snapshot.next_entry_id,
 479                    snapshot.root_char_bag,
 480                );
 481                snapshot.insert_entry(entry, fs.as_ref());
 482            }
 483
 484            let tree = Self {
 485                snapshot: snapshot.clone(),
 486                background_snapshot: Arc::new(Mutex::new(snapshot)),
 487                last_scan_state_rx,
 488                _background_scanner_task: None,
 489                registration: Registration::None,
 490                share: None,
 491                poll_task: None,
 492                diagnostics: Default::default(),
 493                diagnostic_summaries: Default::default(),
 494                client,
 495                fs,
 496                visible,
 497            };
 498
 499            cx.spawn_weak(|this, mut cx| async move {
 500                while let Some(scan_state) = scan_states_rx.next().await {
 501                    if let Some(this) = this.upgrade(&cx) {
 502                        last_scan_state_tx.blocking_send(scan_state).ok();
 503                        this.update(&mut cx, |this, cx| {
 504                            this.poll_snapshot(cx);
 505                            this.as_local().unwrap().broadcast_snapshot()
 506                        })
 507                        .await;
 508                    } else {
 509                        break;
 510                    }
 511                }
 512            })
 513            .detach();
 514
 515            Worktree::Local(tree)
 516        });
 517
 518        Ok((tree, scan_states_tx))
 519    }
 520
 521    pub fn contains_abs_path(&self, path: &Path) -> bool {
 522        path.starts_with(&self.abs_path)
 523    }
 524
 525    fn absolutize(&self, path: &Path) -> PathBuf {
 526        if path.file_name().is_some() {
 527            self.abs_path.join(path)
 528        } else {
 529            self.abs_path.to_path_buf()
 530        }
 531    }
 532
 533    pub(crate) fn load_buffer(
 534        &mut self,
 535        path: &Path,
 536        cx: &mut ModelContext<Worktree>,
 537    ) -> Task<Result<ModelHandle<Buffer>>> {
 538        let path = Arc::from(path);
 539        cx.spawn(move |this, mut cx| async move {
 540            let (file, contents) = this
 541                .update(&mut cx, |t, cx| t.as_local().unwrap().load(&path, cx))
 542                .await?;
 543            Ok(cx.add_model(|cx| Buffer::from_file(0, contents, Box::new(file), cx)))
 544        })
 545    }
 546
 547    pub fn diagnostics_for_path(&self, path: &Path) -> Option<Vec<DiagnosticEntry<PointUtf16>>> {
 548        self.diagnostics.get(path).cloned()
 549    }
 550
 551    pub fn update_diagnostics(
 552        &mut self,
 553        worktree_path: Arc<Path>,
 554        diagnostics: Vec<DiagnosticEntry<PointUtf16>>,
 555        _: &mut ModelContext<Worktree>,
 556    ) -> Result<bool> {
 557        self.diagnostics.remove(&worktree_path);
 558        let old_summary = self
 559            .diagnostic_summaries
 560            .remove(&PathKey(worktree_path.clone()))
 561            .unwrap_or_default();
 562        let new_summary = DiagnosticSummary::new(&diagnostics);
 563        if !new_summary.is_empty() {
 564            self.diagnostic_summaries
 565                .insert(PathKey(worktree_path.clone()), new_summary);
 566            self.diagnostics.insert(worktree_path.clone(), diagnostics);
 567        }
 568
 569        let updated = !old_summary.is_empty() || !new_summary.is_empty();
 570        if updated {
 571            if let Some(share) = self.share.as_ref() {
 572                self.client
 573                    .send(proto::UpdateDiagnosticSummary {
 574                        project_id: share.project_id,
 575                        worktree_id: self.id().to_proto(),
 576                        summary: Some(proto::DiagnosticSummary {
 577                            path: worktree_path.to_string_lossy().to_string(),
 578                            error_count: new_summary.error_count as u32,
 579                            warning_count: new_summary.warning_count as u32,
 580                        }),
 581                    })
 582                    .log_err();
 583            }
 584        }
 585
 586        Ok(updated)
 587    }
 588
 589    pub fn scan_complete(&self) -> impl Future<Output = ()> {
 590        let mut scan_state_rx = self.last_scan_state_rx.clone();
 591        async move {
 592            let mut scan_state = Some(scan_state_rx.borrow().clone());
 593            while let Some(ScanState::Scanning) = scan_state {
 594                scan_state = scan_state_rx.recv().await;
 595            }
 596        }
 597    }
 598
 599    fn is_scanning(&self) -> bool {
 600        if let ScanState::Scanning = *self.last_scan_state_rx.borrow() {
 601            true
 602        } else {
 603            false
 604        }
 605    }
 606
 607    pub fn snapshot(&self) -> LocalSnapshot {
 608        self.snapshot.clone()
 609    }
 610
 611    fn load(&self, path: &Path, cx: &mut ModelContext<Worktree>) -> Task<Result<(File, String)>> {
 612        let handle = cx.handle();
 613        let path = Arc::from(path);
 614        let abs_path = self.absolutize(&path);
 615        let fs = self.fs.clone();
 616        cx.spawn(|this, mut cx| async move {
 617            let text = fs.load(&abs_path).await?;
 618            // Eagerly populate the snapshot with an updated entry for the loaded file
 619            let entry = this
 620                .update(&mut cx, |this, cx| {
 621                    this.as_local()
 622                        .unwrap()
 623                        .refresh_entry(path, abs_path, None, cx)
 624                })
 625                .await?;
 626            this.update(&mut cx, |this, cx| this.poll_snapshot(cx));
 627            Ok((
 628                File {
 629                    entry_id: Some(entry.id),
 630                    worktree: handle,
 631                    path: entry.path,
 632                    mtime: entry.mtime,
 633                    is_local: true,
 634                },
 635                text,
 636            ))
 637        })
 638    }
 639
 640    pub fn save_buffer_as(
 641        &self,
 642        buffer_handle: ModelHandle<Buffer>,
 643        path: impl Into<Arc<Path>>,
 644        cx: &mut ModelContext<Worktree>,
 645    ) -> Task<Result<()>> {
 646        let buffer = buffer_handle.read(cx);
 647        let text = buffer.as_rope().clone();
 648        let version = buffer.version();
 649        let save = self.write_file(path, text, cx);
 650        let handle = cx.handle();
 651        cx.as_mut().spawn(|mut cx| async move {
 652            let entry = save.await?;
 653            let file = File {
 654                entry_id: Some(entry.id),
 655                worktree: handle,
 656                path: entry.path,
 657                mtime: entry.mtime,
 658                is_local: true,
 659            };
 660
 661            buffer_handle.update(&mut cx, |buffer, cx| {
 662                buffer.did_save(version, file.mtime, Some(Box::new(file)), cx);
 663            });
 664
 665            Ok(())
 666        })
 667    }
 668
 669    pub fn create_entry(
 670        &self,
 671        path: impl Into<Arc<Path>>,
 672        is_dir: bool,
 673        cx: &mut ModelContext<Worktree>,
 674    ) -> Task<Result<Entry>> {
 675        self.write_entry_internal(
 676            path,
 677            if is_dir {
 678                None
 679            } else {
 680                Some(Default::default())
 681            },
 682            cx,
 683        )
 684    }
 685
 686    pub fn write_file(
 687        &self,
 688        path: impl Into<Arc<Path>>,
 689        text: Rope,
 690        cx: &mut ModelContext<Worktree>,
 691    ) -> Task<Result<Entry>> {
 692        self.write_entry_internal(path, Some(text), cx)
 693    }
 694
 695    pub fn delete_entry(
 696        &self,
 697        entry_id: ProjectEntryId,
 698        cx: &mut ModelContext<Worktree>,
 699    ) -> Option<Task<Result<()>>> {
 700        let entry = self.entry_for_id(entry_id)?.clone();
 701        let abs_path = self.absolutize(&entry.path);
 702        let delete = cx.background().spawn({
 703            let fs = self.fs.clone();
 704            let abs_path = abs_path.clone();
 705            async move {
 706                if entry.is_file() {
 707                    fs.remove_file(&abs_path, Default::default()).await
 708                } else {
 709                    fs.remove_dir(
 710                        &abs_path,
 711                        RemoveOptions {
 712                            recursive: true,
 713                            ignore_if_not_exists: false,
 714                        },
 715                    )
 716                    .await
 717                }
 718            }
 719        });
 720
 721        Some(cx.spawn(|this, mut cx| async move {
 722            delete.await?;
 723            this.update(&mut cx, |this, _| {
 724                let this = this.as_local_mut().unwrap();
 725                let mut snapshot = this.background_snapshot.lock();
 726                snapshot.delete_entry(entry_id);
 727            });
 728            this.update(&mut cx, |this, cx| {
 729                this.poll_snapshot(cx);
 730                this.as_local().unwrap().broadcast_snapshot()
 731            })
 732            .await;
 733            Ok(())
 734        }))
 735    }
 736
 737    pub fn rename_entry(
 738        &self,
 739        entry_id: ProjectEntryId,
 740        new_path: impl Into<Arc<Path>>,
 741        cx: &mut ModelContext<Worktree>,
 742    ) -> Option<Task<Result<Entry>>> {
 743        let old_path = self.entry_for_id(entry_id)?.path.clone();
 744        let new_path = new_path.into();
 745        let abs_old_path = self.absolutize(&old_path);
 746        let abs_new_path = self.absolutize(&new_path);
 747        let rename = cx.background().spawn({
 748            let fs = self.fs.clone();
 749            let abs_new_path = abs_new_path.clone();
 750            async move {
 751                fs.rename(&abs_old_path, &abs_new_path, Default::default())
 752                    .await
 753            }
 754        });
 755
 756        Some(cx.spawn(|this, mut cx| async move {
 757            rename.await?;
 758            let entry = this
 759                .update(&mut cx, |this, cx| {
 760                    this.as_local_mut().unwrap().refresh_entry(
 761                        new_path.clone(),
 762                        abs_new_path,
 763                        Some(old_path),
 764                        cx,
 765                    )
 766                })
 767                .await?;
 768            this.update(&mut cx, |this, cx| {
 769                this.poll_snapshot(cx);
 770                this.as_local().unwrap().broadcast_snapshot()
 771            })
 772            .await;
 773            Ok(entry)
 774        }))
 775    }
 776
 777    fn write_entry_internal(
 778        &self,
 779        path: impl Into<Arc<Path>>,
 780        text_if_file: Option<Rope>,
 781        cx: &mut ModelContext<Worktree>,
 782    ) -> Task<Result<Entry>> {
 783        let path = path.into();
 784        let abs_path = self.absolutize(&path);
 785        let write = cx.background().spawn({
 786            let fs = self.fs.clone();
 787            let abs_path = abs_path.clone();
 788            async move {
 789                if let Some(text) = text_if_file {
 790                    fs.save(&abs_path, &text).await
 791                } else {
 792                    fs.create_dir(&abs_path).await
 793                }
 794            }
 795        });
 796
 797        cx.spawn(|this, mut cx| async move {
 798            write.await?;
 799            let entry = this
 800                .update(&mut cx, |this, cx| {
 801                    this.as_local_mut()
 802                        .unwrap()
 803                        .refresh_entry(path, abs_path, None, cx)
 804                })
 805                .await?;
 806            this.update(&mut cx, |this, cx| {
 807                this.poll_snapshot(cx);
 808                this.as_local().unwrap().broadcast_snapshot()
 809            })
 810            .await;
 811            Ok(entry)
 812        })
 813    }
 814
 815    fn refresh_entry(
 816        &self,
 817        path: Arc<Path>,
 818        abs_path: PathBuf,
 819        old_path: Option<Arc<Path>>,
 820        cx: &mut ModelContext<Worktree>,
 821    ) -> Task<Result<Entry>> {
 822        let fs = self.fs.clone();
 823        let root_char_bag;
 824        let next_entry_id;
 825        {
 826            let snapshot = self.background_snapshot.lock();
 827            root_char_bag = snapshot.root_char_bag;
 828            next_entry_id = snapshot.next_entry_id.clone();
 829        }
 830        cx.spawn_weak(|this, mut cx| async move {
 831            let entry = Entry::new(
 832                path,
 833                &fs.metadata(&abs_path)
 834                    .await?
 835                    .ok_or_else(|| anyhow!("could not read saved file metadata"))?,
 836                &next_entry_id,
 837                root_char_bag,
 838            );
 839
 840            let this = this
 841                .upgrade(&cx)
 842                .ok_or_else(|| anyhow!("worktree was dropped"))?;
 843            let (entry, snapshot, snapshots_tx) = this.read_with(&cx, |this, _| {
 844                let this = this.as_local().unwrap();
 845                let mut snapshot = this.background_snapshot.lock();
 846                if let Some(old_path) = old_path {
 847                    snapshot.remove_path(&old_path);
 848                }
 849                let entry = snapshot.insert_entry(entry, fs.as_ref());
 850                snapshot.scan_id += 1;
 851                let snapshots_tx = this.share.as_ref().map(|s| s.snapshots_tx.clone());
 852                (entry, snapshot.clone(), snapshots_tx)
 853            });
 854            this.update(&mut cx, |this, cx| this.poll_snapshot(cx));
 855
 856            if let Some(snapshots_tx) = snapshots_tx {
 857                snapshots_tx.send(snapshot).await.ok();
 858            }
 859
 860            Ok(entry)
 861        })
 862    }
 863
 864    pub fn register(
 865        &mut self,
 866        project_id: u64,
 867        cx: &mut ModelContext<Worktree>,
 868    ) -> Task<anyhow::Result<()>> {
 869        if self.registration != Registration::None {
 870            return Task::ready(Ok(()));
 871        }
 872
 873        self.registration = Registration::Pending;
 874        let client = self.client.clone();
 875        let register_message = proto::RegisterWorktree {
 876            project_id,
 877            worktree_id: self.id().to_proto(),
 878            root_name: self.root_name().to_string(),
 879            visible: self.visible,
 880        };
 881        let request = client.request(register_message);
 882        cx.spawn(|this, mut cx| async move {
 883            let response = request.await;
 884            this.update(&mut cx, |this, _| {
 885                let worktree = this.as_local_mut().unwrap();
 886                match response {
 887                    Ok(_) => {
 888                        if worktree.registration == Registration::Pending {
 889                            worktree.registration = Registration::Done { project_id };
 890                        }
 891                        Ok(())
 892                    }
 893                    Err(error) => {
 894                        worktree.registration = Registration::None;
 895                        Err(error)
 896                    }
 897                }
 898            })
 899        })
 900    }
 901
 902    pub fn share(&mut self, project_id: u64, cx: &mut ModelContext<Worktree>) -> Task<Result<()>> {
 903        let register = self.register(project_id, cx);
 904        let (share_tx, share_rx) = oneshot::channel();
 905        let (snapshots_to_send_tx, snapshots_to_send_rx) =
 906            smol::channel::unbounded::<LocalSnapshot>();
 907        if self.share.is_some() {
 908            let _ = share_tx.send(Ok(()));
 909        } else {
 910            let rpc = self.client.clone();
 911            let worktree_id = cx.model_id() as u64;
 912            let maintain_remote_snapshot = cx.background().spawn({
 913                let rpc = rpc.clone();
 914                let diagnostic_summaries = self.diagnostic_summaries.clone();
 915                async move {
 916                    let mut prev_snapshot = match snapshots_to_send_rx.recv().await {
 917                        Ok(snapshot) => {
 918                            if let Err(error) = rpc
 919                                .request(proto::UpdateWorktree {
 920                                    project_id,
 921                                    worktree_id,
 922                                    root_name: snapshot.root_name().to_string(),
 923                                    updated_entries: snapshot
 924                                        .entries_by_path
 925                                        .iter()
 926                                        .filter(|e| !e.is_ignored)
 927                                        .map(Into::into)
 928                                        .collect(),
 929                                    removed_entries: Default::default(),
 930                                    scan_id: snapshot.scan_id as u64,
 931                                })
 932                                .await
 933                            {
 934                                let _ = share_tx.send(Err(error));
 935                                return Err(anyhow!("failed to send initial update worktree"));
 936                            } else {
 937                                let _ = share_tx.send(Ok(()));
 938                                snapshot
 939                            }
 940                        }
 941                        Err(error) => {
 942                            let _ = share_tx.send(Err(error.into()));
 943                            return Err(anyhow!("failed to send initial update worktree"));
 944                        }
 945                    };
 946
 947                    for (path, summary) in diagnostic_summaries.iter() {
 948                        rpc.send(proto::UpdateDiagnosticSummary {
 949                            project_id,
 950                            worktree_id,
 951                            summary: Some(summary.to_proto(&path.0)),
 952                        })?;
 953                    }
 954
 955                    // Stream ignored entries in chunks.
 956                    {
 957                        let mut ignored_entries = prev_snapshot
 958                            .entries_by_path
 959                            .iter()
 960                            .filter(|e| e.is_ignored);
 961                        let mut ignored_entries_to_send = Vec::new();
 962                        loop {
 963                            const CHUNK_SIZE: usize = 256;
 964                            let entry = ignored_entries.next();
 965                            if ignored_entries_to_send.len() >= CHUNK_SIZE || entry.is_none() {
 966                                rpc.request(proto::UpdateWorktree {
 967                                    project_id,
 968                                    worktree_id,
 969                                    root_name: prev_snapshot.root_name().to_string(),
 970                                    updated_entries: mem::take(&mut ignored_entries_to_send),
 971                                    removed_entries: Default::default(),
 972                                    scan_id: prev_snapshot.scan_id as u64,
 973                                })
 974                                .await?;
 975                            }
 976
 977                            if let Some(entry) = ignored_entries.next() {
 978                                ignored_entries_to_send.push(entry.into());
 979                            } else {
 980                                break;
 981                            }
 982                        }
 983                    }
 984
 985                    while let Ok(snapshot) = snapshots_to_send_rx.recv().await {
 986                        let message =
 987                            snapshot.build_update(&prev_snapshot, project_id, worktree_id, true);
 988                        rpc.request(message).await?;
 989                        prev_snapshot = snapshot;
 990                    }
 991
 992                    Ok::<_, anyhow::Error>(())
 993                }
 994                .log_err()
 995            });
 996            self.share = Some(ShareState {
 997                project_id,
 998                snapshots_tx: snapshots_to_send_tx.clone(),
 999                _maintain_remote_snapshot: Some(maintain_remote_snapshot),
1000            });
1001        }
1002
1003        cx.spawn_weak(|this, cx| async move {
1004            register.await?;
1005            if let Some(this) = this.upgrade(&cx) {
1006                this.read_with(&cx, |this, _| {
1007                    let this = this.as_local().unwrap();
1008                    let _ = snapshots_to_send_tx.try_send(this.snapshot());
1009                });
1010            }
1011            share_rx
1012                .await
1013                .unwrap_or_else(|_| Err(anyhow!("share ended")))
1014        })
1015    }
1016
1017    pub fn unregister(&mut self) {
1018        self.unshare();
1019        self.registration = Registration::None;
1020    }
1021
1022    pub fn unshare(&mut self) {
1023        self.share.take();
1024    }
1025
1026    pub fn is_shared(&self) -> bool {
1027        self.share.is_some()
1028    }
1029
1030    fn broadcast_snapshot(&self) -> impl Future<Output = ()> {
1031        let mut to_send = None;
1032        if !self.is_scanning() {
1033            if let Some(share) = self.share.as_ref() {
1034                to_send = Some((self.snapshot(), share.snapshots_tx.clone()));
1035            }
1036        }
1037
1038        async move {
1039            if let Some((snapshot, snapshots_to_send_tx)) = to_send {
1040                if let Err(err) = snapshots_to_send_tx.send(snapshot).await {
1041                    log::error!("error submitting snapshot to send {}", err);
1042                }
1043            }
1044        }
1045    }
1046}
1047
1048impl RemoteWorktree {
1049    fn snapshot(&self) -> Snapshot {
1050        self.snapshot.clone()
1051    }
1052
1053    pub fn update_from_remote(
1054        &mut self,
1055        envelope: TypedEnvelope<proto::UpdateWorktree>,
1056    ) -> Result<()> {
1057        self.updates_tx
1058            .unbounded_send(envelope.payload)
1059            .expect("consumer runs to completion");
1060        Ok(())
1061    }
1062
1063    fn wait_for_snapshot(&self, scan_id: usize) -> impl Future<Output = ()> {
1064        let mut rx = self.last_scan_id_rx.clone();
1065        async move {
1066            while let Some(applied_scan_id) = rx.next().await {
1067                if applied_scan_id >= scan_id {
1068                    return;
1069                }
1070            }
1071        }
1072    }
1073
1074    pub fn update_diagnostic_summary(
1075        &mut self,
1076        path: Arc<Path>,
1077        summary: &proto::DiagnosticSummary,
1078    ) {
1079        let summary = DiagnosticSummary {
1080            error_count: summary.error_count as usize,
1081            warning_count: summary.warning_count as usize,
1082        };
1083        if summary.is_empty() {
1084            self.diagnostic_summaries.remove(&PathKey(path.clone()));
1085        } else {
1086            self.diagnostic_summaries
1087                .insert(PathKey(path.clone()), summary);
1088        }
1089    }
1090
1091    pub fn insert_entry(
1092        &self,
1093        entry: proto::Entry,
1094        scan_id: usize,
1095        cx: &mut ModelContext<Worktree>,
1096    ) -> Task<Result<Entry>> {
1097        let wait_for_snapshot = self.wait_for_snapshot(scan_id);
1098        cx.spawn(|this, mut cx| async move {
1099            wait_for_snapshot.await;
1100            this.update(&mut cx, |worktree, _| {
1101                let worktree = worktree.as_remote_mut().unwrap();
1102                let mut snapshot = worktree.background_snapshot.lock();
1103                let entry = snapshot.insert_entry(entry);
1104                worktree.snapshot = snapshot.clone();
1105                entry
1106            })
1107        })
1108    }
1109
1110    pub(crate) fn delete_entry(
1111        &self,
1112        id: ProjectEntryId,
1113        scan_id: usize,
1114        cx: &mut ModelContext<Worktree>,
1115    ) -> Task<Result<()>> {
1116        let wait_for_snapshot = self.wait_for_snapshot(scan_id);
1117        cx.spawn(|this, mut cx| async move {
1118            wait_for_snapshot.await;
1119            this.update(&mut cx, |worktree, _| {
1120                let worktree = worktree.as_remote_mut().unwrap();
1121                let mut snapshot = worktree.background_snapshot.lock();
1122                snapshot.delete_entry(id);
1123                worktree.snapshot = snapshot.clone();
1124            });
1125            Ok(())
1126        })
1127    }
1128}
1129
1130impl Snapshot {
1131    pub fn id(&self) -> WorktreeId {
1132        self.id
1133    }
1134
1135    pub fn contains_entry(&self, entry_id: ProjectEntryId) -> bool {
1136        self.entries_by_id.get(&entry_id, &()).is_some()
1137    }
1138
1139    pub(crate) fn insert_entry(&mut self, entry: proto::Entry) -> Result<Entry> {
1140        let entry = Entry::try_from((&self.root_char_bag, entry))?;
1141        let old_entry = self.entries_by_id.insert_or_replace(
1142            PathEntry {
1143                id: entry.id,
1144                path: entry.path.clone(),
1145                is_ignored: entry.is_ignored,
1146                scan_id: 0,
1147            },
1148            &(),
1149        );
1150        if let Some(old_entry) = old_entry {
1151            self.entries_by_path.remove(&PathKey(old_entry.path), &());
1152        }
1153        self.entries_by_path.insert_or_replace(entry.clone(), &());
1154        Ok(entry)
1155    }
1156
1157    fn delete_entry(&mut self, entry_id: ProjectEntryId) -> bool {
1158        if let Some(entry) = self.entries_by_id.remove(&entry_id, &()) {
1159            self.entries_by_path.remove(&PathKey(entry.path), &());
1160            true
1161        } else {
1162            false
1163        }
1164    }
1165
1166    pub(crate) fn apply_remote_update(&mut self, update: proto::UpdateWorktree) -> Result<()> {
1167        let mut entries_by_path_edits = Vec::new();
1168        let mut entries_by_id_edits = Vec::new();
1169        for entry_id in update.removed_entries {
1170            let entry = self
1171                .entry_for_id(ProjectEntryId::from_proto(entry_id))
1172                .ok_or_else(|| anyhow!("unknown entry"))?;
1173            entries_by_path_edits.push(Edit::Remove(PathKey(entry.path.clone())));
1174            entries_by_id_edits.push(Edit::Remove(entry.id));
1175        }
1176
1177        for entry in update.updated_entries {
1178            let entry = Entry::try_from((&self.root_char_bag, entry))?;
1179            if let Some(PathEntry { path, .. }) = self.entries_by_id.get(&entry.id, &()) {
1180                entries_by_path_edits.push(Edit::Remove(PathKey(path.clone())));
1181            }
1182            entries_by_id_edits.push(Edit::Insert(PathEntry {
1183                id: entry.id,
1184                path: entry.path.clone(),
1185                is_ignored: entry.is_ignored,
1186                scan_id: 0,
1187            }));
1188            entries_by_path_edits.push(Edit::Insert(entry));
1189        }
1190
1191        self.entries_by_path.edit(entries_by_path_edits, &());
1192        self.entries_by_id.edit(entries_by_id_edits, &());
1193        self.scan_id = update.scan_id as usize;
1194
1195        Ok(())
1196    }
1197
1198    pub fn file_count(&self) -> usize {
1199        self.entries_by_path.summary().file_count
1200    }
1201
1202    pub fn visible_file_count(&self) -> usize {
1203        self.entries_by_path.summary().visible_file_count
1204    }
1205
1206    fn traverse_from_offset(
1207        &self,
1208        include_dirs: bool,
1209        include_ignored: bool,
1210        start_offset: usize,
1211    ) -> Traversal {
1212        let mut cursor = self.entries_by_path.cursor();
1213        cursor.seek(
1214            &TraversalTarget::Count {
1215                count: start_offset,
1216                include_dirs,
1217                include_ignored,
1218            },
1219            Bias::Right,
1220            &(),
1221        );
1222        Traversal {
1223            cursor,
1224            include_dirs,
1225            include_ignored,
1226        }
1227    }
1228
1229    fn traverse_from_path(
1230        &self,
1231        include_dirs: bool,
1232        include_ignored: bool,
1233        path: &Path,
1234    ) -> Traversal {
1235        let mut cursor = self.entries_by_path.cursor();
1236        cursor.seek(&TraversalTarget::Path(path), Bias::Left, &());
1237        Traversal {
1238            cursor,
1239            include_dirs,
1240            include_ignored,
1241        }
1242    }
1243
1244    pub fn files(&self, include_ignored: bool, start: usize) -> Traversal {
1245        self.traverse_from_offset(false, include_ignored, start)
1246    }
1247
1248    pub fn entries(&self, include_ignored: bool) -> Traversal {
1249        self.traverse_from_offset(true, include_ignored, 0)
1250    }
1251
1252    pub fn paths(&self) -> impl Iterator<Item = &Arc<Path>> {
1253        let empty_path = Path::new("");
1254        self.entries_by_path
1255            .cursor::<()>()
1256            .filter(move |entry| entry.path.as_ref() != empty_path)
1257            .map(|entry| &entry.path)
1258    }
1259
1260    fn child_entries<'a>(&'a self, parent_path: &'a Path) -> ChildEntriesIter<'a> {
1261        let mut cursor = self.entries_by_path.cursor();
1262        cursor.seek(&TraversalTarget::Path(parent_path), Bias::Right, &());
1263        let traversal = Traversal {
1264            cursor,
1265            include_dirs: true,
1266            include_ignored: true,
1267        };
1268        ChildEntriesIter {
1269            traversal,
1270            parent_path,
1271        }
1272    }
1273
1274    pub fn root_entry(&self) -> Option<&Entry> {
1275        self.entry_for_path("")
1276    }
1277
1278    pub fn root_name(&self) -> &str {
1279        &self.root_name
1280    }
1281
1282    pub fn scan_id(&self) -> usize {
1283        self.scan_id
1284    }
1285
1286    pub fn entry_for_path(&self, path: impl AsRef<Path>) -> Option<&Entry> {
1287        let path = path.as_ref();
1288        self.traverse_from_path(true, true, path)
1289            .entry()
1290            .and_then(|entry| {
1291                if entry.path.as_ref() == path {
1292                    Some(entry)
1293                } else {
1294                    None
1295                }
1296            })
1297    }
1298
1299    pub fn entry_for_id(&self, id: ProjectEntryId) -> Option<&Entry> {
1300        let entry = self.entries_by_id.get(&id, &())?;
1301        self.entry_for_path(&entry.path)
1302    }
1303
1304    pub fn inode_for_path(&self, path: impl AsRef<Path>) -> Option<u64> {
1305        self.entry_for_path(path.as_ref()).map(|e| e.inode)
1306    }
1307}
1308
1309impl LocalSnapshot {
1310    pub fn abs_path(&self) -> &Arc<Path> {
1311        &self.abs_path
1312    }
1313
1314    #[cfg(test)]
1315    pub(crate) fn to_proto(
1316        &self,
1317        diagnostic_summaries: &TreeMap<PathKey, DiagnosticSummary>,
1318        visible: bool,
1319    ) -> proto::Worktree {
1320        let root_name = self.root_name.clone();
1321        proto::Worktree {
1322            id: self.id.0 as u64,
1323            root_name,
1324            entries: self
1325                .entries_by_path
1326                .iter()
1327                .filter(|e| !e.is_ignored)
1328                .map(Into::into)
1329                .collect(),
1330            diagnostic_summaries: diagnostic_summaries
1331                .iter()
1332                .map(|(path, summary)| summary.to_proto(&path.0))
1333                .collect(),
1334            visible,
1335            scan_id: self.scan_id as u64,
1336        }
1337    }
1338
1339    pub(crate) fn build_update(
1340        &self,
1341        other: &Self,
1342        project_id: u64,
1343        worktree_id: u64,
1344        include_ignored: bool,
1345    ) -> proto::UpdateWorktree {
1346        let mut updated_entries = Vec::new();
1347        let mut removed_entries = Vec::new();
1348        let mut self_entries = self
1349            .entries_by_id
1350            .cursor::<()>()
1351            .filter(|e| include_ignored || !e.is_ignored)
1352            .peekable();
1353        let mut other_entries = other
1354            .entries_by_id
1355            .cursor::<()>()
1356            .filter(|e| include_ignored || !e.is_ignored)
1357            .peekable();
1358        loop {
1359            match (self_entries.peek(), other_entries.peek()) {
1360                (Some(self_entry), Some(other_entry)) => {
1361                    match Ord::cmp(&self_entry.id, &other_entry.id) {
1362                        Ordering::Less => {
1363                            let entry = self.entry_for_id(self_entry.id).unwrap().into();
1364                            updated_entries.push(entry);
1365                            self_entries.next();
1366                        }
1367                        Ordering::Equal => {
1368                            if self_entry.scan_id != other_entry.scan_id {
1369                                let entry = self.entry_for_id(self_entry.id).unwrap().into();
1370                                updated_entries.push(entry);
1371                            }
1372
1373                            self_entries.next();
1374                            other_entries.next();
1375                        }
1376                        Ordering::Greater => {
1377                            removed_entries.push(other_entry.id.to_proto());
1378                            other_entries.next();
1379                        }
1380                    }
1381                }
1382                (Some(self_entry), None) => {
1383                    let entry = self.entry_for_id(self_entry.id).unwrap().into();
1384                    updated_entries.push(entry);
1385                    self_entries.next();
1386                }
1387                (None, Some(other_entry)) => {
1388                    removed_entries.push(other_entry.id.to_proto());
1389                    other_entries.next();
1390                }
1391                (None, None) => break,
1392            }
1393        }
1394
1395        proto::UpdateWorktree {
1396            project_id,
1397            worktree_id,
1398            root_name: self.root_name().to_string(),
1399            updated_entries,
1400            removed_entries,
1401            scan_id: self.scan_id as u64,
1402        }
1403    }
1404
1405    fn insert_entry(&mut self, mut entry: Entry, fs: &dyn Fs) -> Entry {
1406        if !entry.is_dir() && entry.path.file_name() == Some(&GITIGNORE) {
1407            let abs_path = self.abs_path.join(&entry.path);
1408            match build_gitignore(&abs_path, fs) {
1409                Ok(ignore) => {
1410                    let ignore_dir_path = entry.path.parent().unwrap();
1411                    self.ignores
1412                        .insert(ignore_dir_path.into(), (Arc::new(ignore), self.scan_id));
1413                }
1414                Err(error) => {
1415                    log::error!(
1416                        "error loading .gitignore file {:?} - {:?}",
1417                        &entry.path,
1418                        error
1419                    );
1420                }
1421            }
1422        }
1423
1424        self.reuse_entry_id(&mut entry);
1425        self.entries_by_path.insert_or_replace(entry.clone(), &());
1426        let scan_id = self.scan_id;
1427        self.entries_by_id.insert_or_replace(
1428            PathEntry {
1429                id: entry.id,
1430                path: entry.path.clone(),
1431                is_ignored: entry.is_ignored,
1432                scan_id,
1433            },
1434            &(),
1435        );
1436        entry
1437    }
1438
1439    fn populate_dir(
1440        &mut self,
1441        parent_path: Arc<Path>,
1442        entries: impl IntoIterator<Item = Entry>,
1443        ignore: Option<Arc<Gitignore>>,
1444    ) {
1445        let mut parent_entry = if let Some(parent_entry) =
1446            self.entries_by_path.get(&PathKey(parent_path.clone()), &())
1447        {
1448            parent_entry.clone()
1449        } else {
1450            log::warn!(
1451                "populating a directory {:?} that has been removed",
1452                parent_path
1453            );
1454            return;
1455        };
1456
1457        if let Some(ignore) = ignore {
1458            self.ignores.insert(parent_path, (ignore, self.scan_id));
1459        }
1460        if matches!(parent_entry.kind, EntryKind::PendingDir) {
1461            parent_entry.kind = EntryKind::Dir;
1462        } else {
1463            unreachable!();
1464        }
1465
1466        let mut entries_by_path_edits = vec![Edit::Insert(parent_entry)];
1467        let mut entries_by_id_edits = Vec::new();
1468
1469        for mut entry in entries {
1470            self.reuse_entry_id(&mut entry);
1471            entries_by_id_edits.push(Edit::Insert(PathEntry {
1472                id: entry.id,
1473                path: entry.path.clone(),
1474                is_ignored: entry.is_ignored,
1475                scan_id: self.scan_id,
1476            }));
1477            entries_by_path_edits.push(Edit::Insert(entry));
1478        }
1479
1480        self.entries_by_path.edit(entries_by_path_edits, &());
1481        self.entries_by_id.edit(entries_by_id_edits, &());
1482    }
1483
1484    fn reuse_entry_id(&mut self, entry: &mut Entry) {
1485        if let Some(removed_entry_id) = self.removed_entry_ids.remove(&entry.inode) {
1486            entry.id = removed_entry_id;
1487        } else if let Some(existing_entry) = self.entry_for_path(&entry.path) {
1488            entry.id = existing_entry.id;
1489        }
1490    }
1491
1492    fn remove_path(&mut self, path: &Path) {
1493        let mut new_entries;
1494        let removed_entries;
1495        {
1496            let mut cursor = self.entries_by_path.cursor::<TraversalProgress>();
1497            new_entries = cursor.slice(&TraversalTarget::Path(path), Bias::Left, &());
1498            removed_entries = cursor.slice(&TraversalTarget::PathSuccessor(path), Bias::Left, &());
1499            new_entries.push_tree(cursor.suffix(&()), &());
1500        }
1501        self.entries_by_path = new_entries;
1502
1503        let mut entries_by_id_edits = Vec::new();
1504        for entry in removed_entries.cursor::<()>() {
1505            let removed_entry_id = self
1506                .removed_entry_ids
1507                .entry(entry.inode)
1508                .or_insert(entry.id);
1509            *removed_entry_id = cmp::max(*removed_entry_id, entry.id);
1510            entries_by_id_edits.push(Edit::Remove(entry.id));
1511        }
1512        self.entries_by_id.edit(entries_by_id_edits, &());
1513
1514        if path.file_name() == Some(&GITIGNORE) {
1515            if let Some((_, scan_id)) = self.ignores.get_mut(path.parent().unwrap()) {
1516                *scan_id = self.snapshot.scan_id;
1517            }
1518        }
1519    }
1520
1521    fn ignore_stack_for_path(&self, path: &Path, is_dir: bool) -> Arc<IgnoreStack> {
1522        let mut new_ignores = Vec::new();
1523        for ancestor in path.ancestors().skip(1) {
1524            if let Some((ignore, _)) = self.ignores.get(ancestor) {
1525                new_ignores.push((ancestor, Some(ignore.clone())));
1526            } else {
1527                new_ignores.push((ancestor, None));
1528            }
1529        }
1530
1531        let mut ignore_stack = IgnoreStack::none();
1532        for (parent_path, ignore) in new_ignores.into_iter().rev() {
1533            if ignore_stack.is_path_ignored(&parent_path, true) {
1534                ignore_stack = IgnoreStack::all();
1535                break;
1536            } else if let Some(ignore) = ignore {
1537                ignore_stack = ignore_stack.append(Arc::from(parent_path), ignore);
1538            }
1539        }
1540
1541        if ignore_stack.is_path_ignored(path, is_dir) {
1542            ignore_stack = IgnoreStack::all();
1543        }
1544
1545        ignore_stack
1546    }
1547}
1548
1549fn build_gitignore(abs_path: &Path, fs: &dyn Fs) -> Result<Gitignore> {
1550    let contents = smol::block_on(fs.load(&abs_path))?;
1551    let parent = abs_path.parent().unwrap_or(Path::new("/"));
1552    let mut builder = GitignoreBuilder::new(parent);
1553    for line in contents.lines() {
1554        builder.add_line(Some(abs_path.into()), line)?;
1555    }
1556    Ok(builder.build()?)
1557}
1558
1559impl WorktreeId {
1560    pub fn from_usize(handle_id: usize) -> Self {
1561        Self(handle_id)
1562    }
1563
1564    pub(crate) fn from_proto(id: u64) -> Self {
1565        Self(id as usize)
1566    }
1567
1568    pub fn to_proto(&self) -> u64 {
1569        self.0 as u64
1570    }
1571
1572    pub fn to_usize(&self) -> usize {
1573        self.0
1574    }
1575}
1576
1577impl fmt::Display for WorktreeId {
1578    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1579        self.0.fmt(f)
1580    }
1581}
1582
1583impl Deref for Worktree {
1584    type Target = Snapshot;
1585
1586    fn deref(&self) -> &Self::Target {
1587        match self {
1588            Worktree::Local(worktree) => &worktree.snapshot,
1589            Worktree::Remote(worktree) => &worktree.snapshot,
1590        }
1591    }
1592}
1593
1594impl Deref for LocalWorktree {
1595    type Target = LocalSnapshot;
1596
1597    fn deref(&self) -> &Self::Target {
1598        &self.snapshot
1599    }
1600}
1601
1602impl Deref for RemoteWorktree {
1603    type Target = Snapshot;
1604
1605    fn deref(&self) -> &Self::Target {
1606        &self.snapshot
1607    }
1608}
1609
1610impl fmt::Debug for LocalWorktree {
1611    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1612        self.snapshot.fmt(f)
1613    }
1614}
1615
1616impl fmt::Debug for Snapshot {
1617    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1618        struct EntriesById<'a>(&'a SumTree<PathEntry>);
1619        struct EntriesByPath<'a>(&'a SumTree<Entry>);
1620
1621        impl<'a> fmt::Debug for EntriesByPath<'a> {
1622            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1623                f.debug_map()
1624                    .entries(self.0.iter().map(|entry| (&entry.path, entry.id)))
1625                    .finish()
1626            }
1627        }
1628
1629        impl<'a> fmt::Debug for EntriesById<'a> {
1630            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1631                f.debug_list().entries(self.0.iter()).finish()
1632            }
1633        }
1634
1635        f.debug_struct("Snapshot")
1636            .field("id", &self.id)
1637            .field("root_name", &self.root_name)
1638            .field("entries_by_path", &EntriesByPath(&self.entries_by_path))
1639            .field("entries_by_id", &EntriesById(&self.entries_by_id))
1640            .finish()
1641    }
1642}
1643
1644#[derive(Clone, PartialEq)]
1645pub struct File {
1646    pub worktree: ModelHandle<Worktree>,
1647    pub path: Arc<Path>,
1648    pub mtime: SystemTime,
1649    pub(crate) entry_id: Option<ProjectEntryId>,
1650    pub(crate) is_local: bool,
1651}
1652
1653impl language::File for File {
1654    fn as_local(&self) -> Option<&dyn language::LocalFile> {
1655        if self.is_local {
1656            Some(self)
1657        } else {
1658            None
1659        }
1660    }
1661
1662    fn mtime(&self) -> SystemTime {
1663        self.mtime
1664    }
1665
1666    fn path(&self) -> &Arc<Path> {
1667        &self.path
1668    }
1669
1670    fn full_path(&self, cx: &AppContext) -> PathBuf {
1671        let mut full_path = PathBuf::new();
1672        full_path.push(self.worktree.read(cx).root_name());
1673        if self.path.components().next().is_some() {
1674            full_path.push(&self.path);
1675        }
1676        full_path
1677    }
1678
1679    /// Returns the last component of this handle's absolute path. If this handle refers to the root
1680    /// of its worktree, then this method will return the name of the worktree itself.
1681    fn file_name(&self, cx: &AppContext) -> OsString {
1682        self.path
1683            .file_name()
1684            .map(|name| name.into())
1685            .unwrap_or_else(|| OsString::from(&self.worktree.read(cx).root_name))
1686    }
1687
1688    fn is_deleted(&self) -> bool {
1689        self.entry_id.is_none()
1690    }
1691
1692    fn save(
1693        &self,
1694        buffer_id: u64,
1695        text: Rope,
1696        version: clock::Global,
1697        cx: &mut MutableAppContext,
1698    ) -> Task<Result<(clock::Global, SystemTime)>> {
1699        self.worktree.update(cx, |worktree, cx| match worktree {
1700            Worktree::Local(worktree) => {
1701                let rpc = worktree.client.clone();
1702                let project_id = worktree.share.as_ref().map(|share| share.project_id);
1703                let save = worktree.write_file(self.path.clone(), text, cx);
1704                cx.background().spawn(async move {
1705                    let entry = save.await?;
1706                    if let Some(project_id) = project_id {
1707                        rpc.send(proto::BufferSaved {
1708                            project_id,
1709                            buffer_id,
1710                            version: serialize_version(&version),
1711                            mtime: Some(entry.mtime.into()),
1712                        })?;
1713                    }
1714                    Ok((version, entry.mtime))
1715                })
1716            }
1717            Worktree::Remote(worktree) => {
1718                let rpc = worktree.client.clone();
1719                let project_id = worktree.project_id;
1720                cx.foreground().spawn(async move {
1721                    let response = rpc
1722                        .request(proto::SaveBuffer {
1723                            project_id,
1724                            buffer_id,
1725                            version: serialize_version(&version),
1726                        })
1727                        .await?;
1728                    let version = deserialize_version(response.version);
1729                    let mtime = response
1730                        .mtime
1731                        .ok_or_else(|| anyhow!("missing mtime"))?
1732                        .into();
1733                    Ok((version, mtime))
1734                })
1735            }
1736        })
1737    }
1738
1739    fn as_any(&self) -> &dyn Any {
1740        self
1741    }
1742
1743    fn to_proto(&self) -> rpc::proto::File {
1744        rpc::proto::File {
1745            worktree_id: self.worktree.id() as u64,
1746            entry_id: self.entry_id.map(|entry_id| entry_id.to_proto()),
1747            path: self.path.to_string_lossy().into(),
1748            mtime: Some(self.mtime.into()),
1749        }
1750    }
1751}
1752
1753impl language::LocalFile for File {
1754    fn abs_path(&self, cx: &AppContext) -> PathBuf {
1755        self.worktree
1756            .read(cx)
1757            .as_local()
1758            .unwrap()
1759            .abs_path
1760            .join(&self.path)
1761    }
1762
1763    fn load(&self, cx: &AppContext) -> Task<Result<String>> {
1764        let worktree = self.worktree.read(cx).as_local().unwrap();
1765        let abs_path = worktree.absolutize(&self.path);
1766        let fs = worktree.fs.clone();
1767        cx.background()
1768            .spawn(async move { fs.load(&abs_path).await })
1769    }
1770
1771    fn buffer_reloaded(
1772        &self,
1773        buffer_id: u64,
1774        version: &clock::Global,
1775        mtime: SystemTime,
1776        cx: &mut MutableAppContext,
1777    ) {
1778        let worktree = self.worktree.read(cx).as_local().unwrap();
1779        if let Some(project_id) = worktree.share.as_ref().map(|share| share.project_id) {
1780            worktree
1781                .client
1782                .send(proto::BufferReloaded {
1783                    project_id,
1784                    buffer_id,
1785                    version: serialize_version(&version),
1786                    mtime: Some(mtime.into()),
1787                })
1788                .log_err();
1789        }
1790    }
1791}
1792
1793impl File {
1794    pub fn from_proto(
1795        proto: rpc::proto::File,
1796        worktree: ModelHandle<Worktree>,
1797        cx: &AppContext,
1798    ) -> Result<Self> {
1799        let worktree_id = worktree
1800            .read(cx)
1801            .as_remote()
1802            .ok_or_else(|| anyhow!("not remote"))?
1803            .id();
1804
1805        if worktree_id.to_proto() != proto.worktree_id {
1806            return Err(anyhow!("worktree id does not match file"));
1807        }
1808
1809        Ok(Self {
1810            worktree,
1811            path: Path::new(&proto.path).into(),
1812            mtime: proto.mtime.ok_or_else(|| anyhow!("no timestamp"))?.into(),
1813            entry_id: proto.entry_id.map(ProjectEntryId::from_proto),
1814            is_local: false,
1815        })
1816    }
1817
1818    pub fn from_dyn(file: Option<&dyn language::File>) -> Option<&Self> {
1819        file.and_then(|f| f.as_any().downcast_ref())
1820    }
1821
1822    pub fn worktree_id(&self, cx: &AppContext) -> WorktreeId {
1823        self.worktree.read(cx).id()
1824    }
1825
1826    pub fn project_entry_id(&self, _: &AppContext) -> Option<ProjectEntryId> {
1827        self.entry_id
1828    }
1829}
1830
1831#[derive(Clone, Debug, PartialEq, Eq)]
1832pub struct Entry {
1833    pub id: ProjectEntryId,
1834    pub kind: EntryKind,
1835    pub path: Arc<Path>,
1836    pub inode: u64,
1837    pub mtime: SystemTime,
1838    pub is_symlink: bool,
1839    pub is_ignored: bool,
1840}
1841
1842#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1843pub enum EntryKind {
1844    PendingDir,
1845    Dir,
1846    File(CharBag),
1847}
1848
1849impl Entry {
1850    fn new(
1851        path: Arc<Path>,
1852        metadata: &fs::Metadata,
1853        next_entry_id: &AtomicUsize,
1854        root_char_bag: CharBag,
1855    ) -> Self {
1856        Self {
1857            id: ProjectEntryId::new(next_entry_id),
1858            kind: if metadata.is_dir {
1859                EntryKind::PendingDir
1860            } else {
1861                EntryKind::File(char_bag_for_path(root_char_bag, &path))
1862            },
1863            path,
1864            inode: metadata.inode,
1865            mtime: metadata.mtime,
1866            is_symlink: metadata.is_symlink,
1867            is_ignored: false,
1868        }
1869    }
1870
1871    pub fn is_dir(&self) -> bool {
1872        matches!(self.kind, EntryKind::Dir | EntryKind::PendingDir)
1873    }
1874
1875    pub fn is_file(&self) -> bool {
1876        matches!(self.kind, EntryKind::File(_))
1877    }
1878}
1879
1880impl sum_tree::Item for Entry {
1881    type Summary = EntrySummary;
1882
1883    fn summary(&self) -> Self::Summary {
1884        let visible_count = if self.is_ignored { 0 } else { 1 };
1885        let file_count;
1886        let visible_file_count;
1887        if self.is_file() {
1888            file_count = 1;
1889            visible_file_count = visible_count;
1890        } else {
1891            file_count = 0;
1892            visible_file_count = 0;
1893        }
1894
1895        EntrySummary {
1896            max_path: self.path.clone(),
1897            count: 1,
1898            visible_count,
1899            file_count,
1900            visible_file_count,
1901        }
1902    }
1903}
1904
1905impl sum_tree::KeyedItem for Entry {
1906    type Key = PathKey;
1907
1908    fn key(&self) -> Self::Key {
1909        PathKey(self.path.clone())
1910    }
1911}
1912
1913#[derive(Clone, Debug)]
1914pub struct EntrySummary {
1915    max_path: Arc<Path>,
1916    count: usize,
1917    visible_count: usize,
1918    file_count: usize,
1919    visible_file_count: usize,
1920}
1921
1922impl Default for EntrySummary {
1923    fn default() -> Self {
1924        Self {
1925            max_path: Arc::from(Path::new("")),
1926            count: 0,
1927            visible_count: 0,
1928            file_count: 0,
1929            visible_file_count: 0,
1930        }
1931    }
1932}
1933
1934impl sum_tree::Summary for EntrySummary {
1935    type Context = ();
1936
1937    fn add_summary(&mut self, rhs: &Self, _: &()) {
1938        self.max_path = rhs.max_path.clone();
1939        self.count += rhs.count;
1940        self.visible_count += rhs.visible_count;
1941        self.file_count += rhs.file_count;
1942        self.visible_file_count += rhs.visible_file_count;
1943    }
1944}
1945
1946#[derive(Clone, Debug)]
1947struct PathEntry {
1948    id: ProjectEntryId,
1949    path: Arc<Path>,
1950    is_ignored: bool,
1951    scan_id: usize,
1952}
1953
1954impl sum_tree::Item for PathEntry {
1955    type Summary = PathEntrySummary;
1956
1957    fn summary(&self) -> Self::Summary {
1958        PathEntrySummary { max_id: self.id }
1959    }
1960}
1961
1962impl sum_tree::KeyedItem for PathEntry {
1963    type Key = ProjectEntryId;
1964
1965    fn key(&self) -> Self::Key {
1966        self.id
1967    }
1968}
1969
1970#[derive(Clone, Debug, Default)]
1971struct PathEntrySummary {
1972    max_id: ProjectEntryId,
1973}
1974
1975impl sum_tree::Summary for PathEntrySummary {
1976    type Context = ();
1977
1978    fn add_summary(&mut self, summary: &Self, _: &Self::Context) {
1979        self.max_id = summary.max_id;
1980    }
1981}
1982
1983impl<'a> sum_tree::Dimension<'a, PathEntrySummary> for ProjectEntryId {
1984    fn add_summary(&mut self, summary: &'a PathEntrySummary, _: &()) {
1985        *self = summary.max_id;
1986    }
1987}
1988
1989#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
1990pub struct PathKey(Arc<Path>);
1991
1992impl Default for PathKey {
1993    fn default() -> Self {
1994        Self(Path::new("").into())
1995    }
1996}
1997
1998impl<'a> sum_tree::Dimension<'a, EntrySummary> for PathKey {
1999    fn add_summary(&mut self, summary: &'a EntrySummary, _: &()) {
2000        self.0 = summary.max_path.clone();
2001    }
2002}
2003
2004struct BackgroundScanner {
2005    fs: Arc<dyn Fs>,
2006    snapshot: Arc<Mutex<LocalSnapshot>>,
2007    notify: UnboundedSender<ScanState>,
2008    executor: Arc<executor::Background>,
2009}
2010
2011impl BackgroundScanner {
2012    fn new(
2013        snapshot: Arc<Mutex<LocalSnapshot>>,
2014        notify: UnboundedSender<ScanState>,
2015        fs: Arc<dyn Fs>,
2016        executor: Arc<executor::Background>,
2017    ) -> Self {
2018        Self {
2019            fs,
2020            snapshot,
2021            notify,
2022            executor,
2023        }
2024    }
2025
2026    fn abs_path(&self) -> Arc<Path> {
2027        self.snapshot.lock().abs_path.clone()
2028    }
2029
2030    fn snapshot(&self) -> LocalSnapshot {
2031        self.snapshot.lock().clone()
2032    }
2033
2034    async fn run(mut self, events_rx: impl Stream<Item = Vec<fsevent::Event>>) {
2035        if self.notify.unbounded_send(ScanState::Scanning).is_err() {
2036            return;
2037        }
2038
2039        if let Err(err) = self.scan_dirs().await {
2040            if self
2041                .notify
2042                .unbounded_send(ScanState::Err(Arc::new(err)))
2043                .is_err()
2044            {
2045                return;
2046            }
2047        }
2048
2049        if self.notify.unbounded_send(ScanState::Idle).is_err() {
2050            return;
2051        }
2052
2053        futures::pin_mut!(events_rx);
2054        while let Some(events) = events_rx.next().await {
2055            if self.notify.unbounded_send(ScanState::Scanning).is_err() {
2056                break;
2057            }
2058
2059            if !self.process_events(events).await {
2060                break;
2061            }
2062
2063            if self.notify.unbounded_send(ScanState::Idle).is_err() {
2064                break;
2065            }
2066        }
2067    }
2068
2069    async fn scan_dirs(&mut self) -> Result<()> {
2070        let root_char_bag;
2071        let next_entry_id;
2072        let is_dir;
2073        {
2074            let snapshot = self.snapshot.lock();
2075            root_char_bag = snapshot.root_char_bag;
2076            next_entry_id = snapshot.next_entry_id.clone();
2077            is_dir = snapshot.root_entry().map_or(false, |e| e.is_dir())
2078        };
2079
2080        if is_dir {
2081            let path: Arc<Path> = Arc::from(Path::new(""));
2082            let abs_path = self.abs_path();
2083            let (tx, rx) = channel::unbounded();
2084            self.executor
2085                .block(tx.send(ScanJob {
2086                    abs_path: abs_path.to_path_buf(),
2087                    path,
2088                    ignore_stack: IgnoreStack::none(),
2089                    scan_queue: tx.clone(),
2090                }))
2091                .unwrap();
2092            drop(tx);
2093
2094            self.executor
2095                .scoped(|scope| {
2096                    for _ in 0..self.executor.num_cpus() {
2097                        scope.spawn(async {
2098                            while let Ok(job) = rx.recv().await {
2099                                if let Err(err) = self
2100                                    .scan_dir(root_char_bag, next_entry_id.clone(), &job)
2101                                    .await
2102                                {
2103                                    log::error!("error scanning {:?}: {}", job.abs_path, err);
2104                                }
2105                            }
2106                        });
2107                    }
2108                })
2109                .await;
2110        }
2111
2112        Ok(())
2113    }
2114
2115    async fn scan_dir(
2116        &self,
2117        root_char_bag: CharBag,
2118        next_entry_id: Arc<AtomicUsize>,
2119        job: &ScanJob,
2120    ) -> Result<()> {
2121        let mut new_entries: Vec<Entry> = Vec::new();
2122        let mut new_jobs: Vec<ScanJob> = Vec::new();
2123        let mut ignore_stack = job.ignore_stack.clone();
2124        let mut new_ignore = None;
2125
2126        let mut child_paths = self.fs.read_dir(&job.abs_path).await?;
2127        while let Some(child_abs_path) = child_paths.next().await {
2128            let child_abs_path = match child_abs_path {
2129                Ok(child_abs_path) => child_abs_path,
2130                Err(error) => {
2131                    log::error!("error processing entry {:?}", error);
2132                    continue;
2133                }
2134            };
2135            let child_name = child_abs_path.file_name().unwrap();
2136            let child_path: Arc<Path> = job.path.join(child_name).into();
2137            let child_metadata = match self.fs.metadata(&child_abs_path).await? {
2138                Some(metadata) => metadata,
2139                None => continue,
2140            };
2141
2142            // If we find a .gitignore, add it to the stack of ignores used to determine which paths are ignored
2143            if child_name == *GITIGNORE {
2144                match build_gitignore(&child_abs_path, self.fs.as_ref()) {
2145                    Ok(ignore) => {
2146                        let ignore = Arc::new(ignore);
2147                        ignore_stack = ignore_stack.append(job.path.clone(), ignore.clone());
2148                        new_ignore = Some(ignore);
2149                    }
2150                    Err(error) => {
2151                        log::error!(
2152                            "error loading .gitignore file {:?} - {:?}",
2153                            child_name,
2154                            error
2155                        );
2156                    }
2157                }
2158
2159                // Update ignore status of any child entries we've already processed to reflect the
2160                // ignore file in the current directory. Because `.gitignore` starts with a `.`,
2161                // there should rarely be too numerous. Update the ignore stack associated with any
2162                // new jobs as well.
2163                let mut new_jobs = new_jobs.iter_mut();
2164                for entry in &mut new_entries {
2165                    entry.is_ignored = ignore_stack.is_path_ignored(&entry.path, entry.is_dir());
2166                    if entry.is_dir() {
2167                        new_jobs.next().unwrap().ignore_stack = if entry.is_ignored {
2168                            IgnoreStack::all()
2169                        } else {
2170                            ignore_stack.clone()
2171                        };
2172                    }
2173                }
2174            }
2175
2176            let mut child_entry = Entry::new(
2177                child_path.clone(),
2178                &child_metadata,
2179                &next_entry_id,
2180                root_char_bag,
2181            );
2182
2183            if child_metadata.is_dir {
2184                let is_ignored = ignore_stack.is_path_ignored(&child_path, true);
2185                child_entry.is_ignored = is_ignored;
2186                new_entries.push(child_entry);
2187                new_jobs.push(ScanJob {
2188                    abs_path: child_abs_path,
2189                    path: child_path,
2190                    ignore_stack: if is_ignored {
2191                        IgnoreStack::all()
2192                    } else {
2193                        ignore_stack.clone()
2194                    },
2195                    scan_queue: job.scan_queue.clone(),
2196                });
2197            } else {
2198                child_entry.is_ignored = ignore_stack.is_path_ignored(&child_path, false);
2199                new_entries.push(child_entry);
2200            };
2201        }
2202
2203        self.snapshot
2204            .lock()
2205            .populate_dir(job.path.clone(), new_entries, new_ignore);
2206        for new_job in new_jobs {
2207            job.scan_queue.send(new_job).await.unwrap();
2208        }
2209
2210        Ok(())
2211    }
2212
2213    async fn process_events(&mut self, mut events: Vec<fsevent::Event>) -> bool {
2214        events.sort_unstable_by(|a, b| a.path.cmp(&b.path));
2215        events.dedup_by(|a, b| a.path.starts_with(&b.path));
2216
2217        let root_char_bag;
2218        let root_abs_path;
2219        let next_entry_id;
2220        {
2221            let snapshot = self.snapshot.lock();
2222            root_char_bag = snapshot.root_char_bag;
2223            root_abs_path = snapshot.abs_path.clone();
2224            next_entry_id = snapshot.next_entry_id.clone();
2225        }
2226
2227        let root_abs_path = if let Ok(abs_path) = self.fs.canonicalize(&root_abs_path).await {
2228            abs_path
2229        } else {
2230            return false;
2231        };
2232        let metadata = futures::future::join_all(
2233            events
2234                .iter()
2235                .map(|event| self.fs.metadata(&event.path))
2236                .collect::<Vec<_>>(),
2237        )
2238        .await;
2239
2240        // Hold the snapshot lock while clearing and re-inserting the root entries
2241        // for each event. This way, the snapshot is not observable to the foreground
2242        // thread while this operation is in-progress.
2243        let (scan_queue_tx, scan_queue_rx) = channel::unbounded();
2244        {
2245            let mut snapshot = self.snapshot.lock();
2246            snapshot.scan_id += 1;
2247            for event in &events {
2248                if let Ok(path) = event.path.strip_prefix(&root_abs_path) {
2249                    snapshot.remove_path(&path);
2250                }
2251            }
2252
2253            for (event, metadata) in events.into_iter().zip(metadata.into_iter()) {
2254                let path: Arc<Path> = match event.path.strip_prefix(&root_abs_path) {
2255                    Ok(path) => Arc::from(path.to_path_buf()),
2256                    Err(_) => {
2257                        log::error!(
2258                            "unexpected event {:?} for root path {:?}",
2259                            event.path,
2260                            root_abs_path
2261                        );
2262                        continue;
2263                    }
2264                };
2265
2266                match metadata {
2267                    Ok(Some(metadata)) => {
2268                        let ignore_stack = snapshot.ignore_stack_for_path(&path, metadata.is_dir);
2269                        let mut fs_entry = Entry::new(
2270                            path.clone(),
2271                            &metadata,
2272                            snapshot.next_entry_id.as_ref(),
2273                            snapshot.root_char_bag,
2274                        );
2275                        fs_entry.is_ignored = ignore_stack.is_all();
2276                        snapshot.insert_entry(fs_entry, self.fs.as_ref());
2277                        if metadata.is_dir {
2278                            self.executor
2279                                .block(scan_queue_tx.send(ScanJob {
2280                                    abs_path: event.path,
2281                                    path,
2282                                    ignore_stack,
2283                                    scan_queue: scan_queue_tx.clone(),
2284                                }))
2285                                .unwrap();
2286                        }
2287                    }
2288                    Ok(None) => {}
2289                    Err(err) => {
2290                        // TODO - create a special 'error' entry in the entries tree to mark this
2291                        log::error!("error reading file on event {:?}", err);
2292                    }
2293                }
2294            }
2295            drop(scan_queue_tx);
2296        }
2297
2298        // Scan any directories that were created as part of this event batch.
2299        self.executor
2300            .scoped(|scope| {
2301                for _ in 0..self.executor.num_cpus() {
2302                    scope.spawn(async {
2303                        while let Ok(job) = scan_queue_rx.recv().await {
2304                            if let Err(err) = self
2305                                .scan_dir(root_char_bag, next_entry_id.clone(), &job)
2306                                .await
2307                            {
2308                                log::error!("error scanning {:?}: {}", job.abs_path, err);
2309                            }
2310                        }
2311                    });
2312                }
2313            })
2314            .await;
2315
2316        // Attempt to detect renames only over a single batch of file-system events.
2317        self.snapshot.lock().removed_entry_ids.clear();
2318
2319        self.update_ignore_statuses().await;
2320        true
2321    }
2322
2323    async fn update_ignore_statuses(&self) {
2324        let mut snapshot = self.snapshot();
2325
2326        let mut ignores_to_update = Vec::new();
2327        let mut ignores_to_delete = Vec::new();
2328        for (parent_path, (_, scan_id)) in &snapshot.ignores {
2329            if *scan_id == snapshot.scan_id && snapshot.entry_for_path(parent_path).is_some() {
2330                ignores_to_update.push(parent_path.clone());
2331            }
2332
2333            let ignore_path = parent_path.join(&*GITIGNORE);
2334            if snapshot.entry_for_path(ignore_path).is_none() {
2335                ignores_to_delete.push(parent_path.clone());
2336            }
2337        }
2338
2339        for parent_path in ignores_to_delete {
2340            snapshot.ignores.remove(&parent_path);
2341            self.snapshot.lock().ignores.remove(&parent_path);
2342        }
2343
2344        let (ignore_queue_tx, ignore_queue_rx) = channel::unbounded();
2345        ignores_to_update.sort_unstable();
2346        let mut ignores_to_update = ignores_to_update.into_iter().peekable();
2347        while let Some(parent_path) = ignores_to_update.next() {
2348            while ignores_to_update
2349                .peek()
2350                .map_or(false, |p| p.starts_with(&parent_path))
2351            {
2352                ignores_to_update.next().unwrap();
2353            }
2354
2355            let ignore_stack = snapshot.ignore_stack_for_path(&parent_path, true);
2356            ignore_queue_tx
2357                .send(UpdateIgnoreStatusJob {
2358                    path: parent_path,
2359                    ignore_stack,
2360                    ignore_queue: ignore_queue_tx.clone(),
2361                })
2362                .await
2363                .unwrap();
2364        }
2365        drop(ignore_queue_tx);
2366
2367        self.executor
2368            .scoped(|scope| {
2369                for _ in 0..self.executor.num_cpus() {
2370                    scope.spawn(async {
2371                        while let Ok(job) = ignore_queue_rx.recv().await {
2372                            self.update_ignore_status(job, &snapshot).await;
2373                        }
2374                    });
2375                }
2376            })
2377            .await;
2378    }
2379
2380    async fn update_ignore_status(&self, job: UpdateIgnoreStatusJob, snapshot: &LocalSnapshot) {
2381        let mut ignore_stack = job.ignore_stack;
2382        if let Some((ignore, _)) = snapshot.ignores.get(&job.path) {
2383            ignore_stack = ignore_stack.append(job.path.clone(), ignore.clone());
2384        }
2385
2386        let mut entries_by_id_edits = Vec::new();
2387        let mut entries_by_path_edits = Vec::new();
2388        for mut entry in snapshot.child_entries(&job.path).cloned() {
2389            let was_ignored = entry.is_ignored;
2390            entry.is_ignored = ignore_stack.is_path_ignored(&entry.path, entry.is_dir());
2391            if entry.is_dir() {
2392                let child_ignore_stack = if entry.is_ignored {
2393                    IgnoreStack::all()
2394                } else {
2395                    ignore_stack.clone()
2396                };
2397                job.ignore_queue
2398                    .send(UpdateIgnoreStatusJob {
2399                        path: entry.path.clone(),
2400                        ignore_stack: child_ignore_stack,
2401                        ignore_queue: job.ignore_queue.clone(),
2402                    })
2403                    .await
2404                    .unwrap();
2405            }
2406
2407            if entry.is_ignored != was_ignored {
2408                let mut path_entry = snapshot.entries_by_id.get(&entry.id, &()).unwrap().clone();
2409                path_entry.scan_id = snapshot.scan_id;
2410                path_entry.is_ignored = entry.is_ignored;
2411                entries_by_id_edits.push(Edit::Insert(path_entry));
2412                entries_by_path_edits.push(Edit::Insert(entry));
2413            }
2414        }
2415
2416        let mut snapshot = self.snapshot.lock();
2417        snapshot.entries_by_path.edit(entries_by_path_edits, &());
2418        snapshot.entries_by_id.edit(entries_by_id_edits, &());
2419    }
2420}
2421
2422fn char_bag_for_path(root_char_bag: CharBag, path: &Path) -> CharBag {
2423    let mut result = root_char_bag;
2424    result.extend(
2425        path.to_string_lossy()
2426            .chars()
2427            .map(|c| c.to_ascii_lowercase()),
2428    );
2429    result
2430}
2431
2432struct ScanJob {
2433    abs_path: PathBuf,
2434    path: Arc<Path>,
2435    ignore_stack: Arc<IgnoreStack>,
2436    scan_queue: Sender<ScanJob>,
2437}
2438
2439struct UpdateIgnoreStatusJob {
2440    path: Arc<Path>,
2441    ignore_stack: Arc<IgnoreStack>,
2442    ignore_queue: Sender<UpdateIgnoreStatusJob>,
2443}
2444
2445pub trait WorktreeHandle {
2446    #[cfg(any(test, feature = "test-support"))]
2447    fn flush_fs_events<'a>(
2448        &self,
2449        cx: &'a gpui::TestAppContext,
2450    ) -> futures::future::LocalBoxFuture<'a, ()>;
2451}
2452
2453impl WorktreeHandle for ModelHandle<Worktree> {
2454    // When the worktree's FS event stream sometimes delivers "redundant" events for FS changes that
2455    // occurred before the worktree was constructed. These events can cause the worktree to perfrom
2456    // extra directory scans, and emit extra scan-state notifications.
2457    //
2458    // This function mutates the worktree's directory and waits for those mutations to be picked up,
2459    // to ensure that all redundant FS events have already been processed.
2460    #[cfg(any(test, feature = "test-support"))]
2461    fn flush_fs_events<'a>(
2462        &self,
2463        cx: &'a gpui::TestAppContext,
2464    ) -> futures::future::LocalBoxFuture<'a, ()> {
2465        use smol::future::FutureExt;
2466
2467        let filename = "fs-event-sentinel";
2468        let tree = self.clone();
2469        let (fs, root_path) = self.read_with(cx, |tree, _| {
2470            let tree = tree.as_local().unwrap();
2471            (tree.fs.clone(), tree.abs_path().clone())
2472        });
2473
2474        async move {
2475            fs.create_file(&root_path.join(filename), Default::default())
2476                .await
2477                .unwrap();
2478            tree.condition(&cx, |tree, _| tree.entry_for_path(filename).is_some())
2479                .await;
2480
2481            fs.remove_file(&root_path.join(filename), Default::default())
2482                .await
2483                .unwrap();
2484            tree.condition(&cx, |tree, _| tree.entry_for_path(filename).is_none())
2485                .await;
2486
2487            cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
2488                .await;
2489        }
2490        .boxed_local()
2491    }
2492}
2493
2494#[derive(Clone, Debug)]
2495struct TraversalProgress<'a> {
2496    max_path: &'a Path,
2497    count: usize,
2498    visible_count: usize,
2499    file_count: usize,
2500    visible_file_count: usize,
2501}
2502
2503impl<'a> TraversalProgress<'a> {
2504    fn count(&self, include_dirs: bool, include_ignored: bool) -> usize {
2505        match (include_ignored, include_dirs) {
2506            (true, true) => self.count,
2507            (true, false) => self.file_count,
2508            (false, true) => self.visible_count,
2509            (false, false) => self.visible_file_count,
2510        }
2511    }
2512}
2513
2514impl<'a> sum_tree::Dimension<'a, EntrySummary> for TraversalProgress<'a> {
2515    fn add_summary(&mut self, summary: &'a EntrySummary, _: &()) {
2516        self.max_path = summary.max_path.as_ref();
2517        self.count += summary.count;
2518        self.visible_count += summary.visible_count;
2519        self.file_count += summary.file_count;
2520        self.visible_file_count += summary.visible_file_count;
2521    }
2522}
2523
2524impl<'a> Default for TraversalProgress<'a> {
2525    fn default() -> Self {
2526        Self {
2527            max_path: Path::new(""),
2528            count: 0,
2529            visible_count: 0,
2530            file_count: 0,
2531            visible_file_count: 0,
2532        }
2533    }
2534}
2535
2536pub struct Traversal<'a> {
2537    cursor: sum_tree::Cursor<'a, Entry, TraversalProgress<'a>>,
2538    include_ignored: bool,
2539    include_dirs: bool,
2540}
2541
2542impl<'a> Traversal<'a> {
2543    pub fn advance(&mut self) -> bool {
2544        self.advance_to_offset(self.offset() + 1)
2545    }
2546
2547    pub fn advance_to_offset(&mut self, offset: usize) -> bool {
2548        self.cursor.seek_forward(
2549            &TraversalTarget::Count {
2550                count: offset,
2551                include_dirs: self.include_dirs,
2552                include_ignored: self.include_ignored,
2553            },
2554            Bias::Right,
2555            &(),
2556        )
2557    }
2558
2559    pub fn advance_to_sibling(&mut self) -> bool {
2560        while let Some(entry) = self.cursor.item() {
2561            self.cursor.seek_forward(
2562                &TraversalTarget::PathSuccessor(&entry.path),
2563                Bias::Left,
2564                &(),
2565            );
2566            if let Some(entry) = self.cursor.item() {
2567                if (self.include_dirs || !entry.is_dir())
2568                    && (self.include_ignored || !entry.is_ignored)
2569                {
2570                    return true;
2571                }
2572            }
2573        }
2574        false
2575    }
2576
2577    pub fn entry(&self) -> Option<&'a Entry> {
2578        self.cursor.item()
2579    }
2580
2581    pub fn offset(&self) -> usize {
2582        self.cursor
2583            .start()
2584            .count(self.include_dirs, self.include_ignored)
2585    }
2586}
2587
2588impl<'a> Iterator for Traversal<'a> {
2589    type Item = &'a Entry;
2590
2591    fn next(&mut self) -> Option<Self::Item> {
2592        if let Some(item) = self.entry() {
2593            self.advance();
2594            Some(item)
2595        } else {
2596            None
2597        }
2598    }
2599}
2600
2601#[derive(Debug)]
2602enum TraversalTarget<'a> {
2603    Path(&'a Path),
2604    PathSuccessor(&'a Path),
2605    Count {
2606        count: usize,
2607        include_ignored: bool,
2608        include_dirs: bool,
2609    },
2610}
2611
2612impl<'a, 'b> SeekTarget<'a, EntrySummary, TraversalProgress<'a>> for TraversalTarget<'b> {
2613    fn cmp(&self, cursor_location: &TraversalProgress<'a>, _: &()) -> Ordering {
2614        match self {
2615            TraversalTarget::Path(path) => path.cmp(&cursor_location.max_path),
2616            TraversalTarget::PathSuccessor(path) => {
2617                if !cursor_location.max_path.starts_with(path) {
2618                    Ordering::Equal
2619                } else {
2620                    Ordering::Greater
2621                }
2622            }
2623            TraversalTarget::Count {
2624                count,
2625                include_dirs,
2626                include_ignored,
2627            } => Ord::cmp(
2628                count,
2629                &cursor_location.count(*include_dirs, *include_ignored),
2630            ),
2631        }
2632    }
2633}
2634
2635struct ChildEntriesIter<'a> {
2636    parent_path: &'a Path,
2637    traversal: Traversal<'a>,
2638}
2639
2640impl<'a> Iterator for ChildEntriesIter<'a> {
2641    type Item = &'a Entry;
2642
2643    fn next(&mut self) -> Option<Self::Item> {
2644        if let Some(item) = self.traversal.entry() {
2645            if item.path.starts_with(&self.parent_path) {
2646                self.traversal.advance_to_sibling();
2647                return Some(item);
2648            }
2649        }
2650        None
2651    }
2652}
2653
2654impl<'a> From<&'a Entry> for proto::Entry {
2655    fn from(entry: &'a Entry) -> Self {
2656        Self {
2657            id: entry.id.to_proto(),
2658            is_dir: entry.is_dir(),
2659            path: entry.path.as_os_str().as_bytes().to_vec(),
2660            inode: entry.inode,
2661            mtime: Some(entry.mtime.into()),
2662            is_symlink: entry.is_symlink,
2663            is_ignored: entry.is_ignored,
2664        }
2665    }
2666}
2667
2668impl<'a> TryFrom<(&'a CharBag, proto::Entry)> for Entry {
2669    type Error = anyhow::Error;
2670
2671    fn try_from((root_char_bag, entry): (&'a CharBag, proto::Entry)) -> Result<Self> {
2672        if let Some(mtime) = entry.mtime {
2673            let kind = if entry.is_dir {
2674                EntryKind::Dir
2675            } else {
2676                let mut char_bag = root_char_bag.clone();
2677                char_bag.extend(
2678                    String::from_utf8_lossy(&entry.path)
2679                        .chars()
2680                        .map(|c| c.to_ascii_lowercase()),
2681                );
2682                EntryKind::File(char_bag)
2683            };
2684            let path: Arc<Path> = PathBuf::from(OsString::from_vec(entry.path)).into();
2685            Ok(Entry {
2686                id: ProjectEntryId::from_proto(entry.id),
2687                kind,
2688                path: path.clone(),
2689                inode: entry.inode,
2690                mtime: mtime.into(),
2691                is_symlink: entry.is_symlink,
2692                is_ignored: entry.is_ignored,
2693            })
2694        } else {
2695            Err(anyhow!(
2696                "missing mtime in remote worktree entry {:?}",
2697                entry.path
2698            ))
2699        }
2700    }
2701}
2702
2703#[cfg(test)]
2704mod tests {
2705    use super::*;
2706    use crate::fs::FakeFs;
2707    use anyhow::Result;
2708    use client::test::FakeHttpClient;
2709    use fs::RealFs;
2710    use rand::prelude::*;
2711    use serde_json::json;
2712    use std::{
2713        env,
2714        fmt::Write,
2715        time::{SystemTime, UNIX_EPOCH},
2716    };
2717    use util::test::temp_tree;
2718
2719    #[gpui::test]
2720    async fn test_traversal(cx: &mut gpui::TestAppContext) {
2721        let fs = FakeFs::new(cx.background());
2722        fs.insert_tree(
2723            "/root",
2724            json!({
2725               ".gitignore": "a/b\n",
2726               "a": {
2727                   "b": "",
2728                   "c": "",
2729               }
2730            }),
2731        )
2732        .await;
2733
2734        let http_client = FakeHttpClient::with_404_response();
2735        let client = Client::new(http_client);
2736
2737        let tree = Worktree::local(
2738            client,
2739            Arc::from(Path::new("/root")),
2740            true,
2741            fs,
2742            Default::default(),
2743            &mut cx.to_async(),
2744        )
2745        .await
2746        .unwrap();
2747        cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
2748            .await;
2749
2750        tree.read_with(cx, |tree, _| {
2751            assert_eq!(
2752                tree.entries(false)
2753                    .map(|entry| entry.path.as_ref())
2754                    .collect::<Vec<_>>(),
2755                vec![
2756                    Path::new(""),
2757                    Path::new(".gitignore"),
2758                    Path::new("a"),
2759                    Path::new("a/c"),
2760                ]
2761            );
2762            assert_eq!(
2763                tree.entries(true)
2764                    .map(|entry| entry.path.as_ref())
2765                    .collect::<Vec<_>>(),
2766                vec![
2767                    Path::new(""),
2768                    Path::new(".gitignore"),
2769                    Path::new("a"),
2770                    Path::new("a/b"),
2771                    Path::new("a/c"),
2772                ]
2773            );
2774        })
2775    }
2776
2777    #[gpui::test]
2778    async fn test_rescan_with_gitignore(cx: &mut gpui::TestAppContext) {
2779        let dir = temp_tree(json!({
2780            ".git": {},
2781            ".gitignore": "ignored-dir\n",
2782            "tracked-dir": {
2783                "tracked-file1": "tracked contents",
2784            },
2785            "ignored-dir": {
2786                "ignored-file1": "ignored contents",
2787            }
2788        }));
2789
2790        let http_client = FakeHttpClient::with_404_response();
2791        let client = Client::new(http_client.clone());
2792
2793        let tree = Worktree::local(
2794            client,
2795            dir.path(),
2796            true,
2797            Arc::new(RealFs),
2798            Default::default(),
2799            &mut cx.to_async(),
2800        )
2801        .await
2802        .unwrap();
2803        cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
2804            .await;
2805        tree.flush_fs_events(&cx).await;
2806        cx.read(|cx| {
2807            let tree = tree.read(cx);
2808            let tracked = tree.entry_for_path("tracked-dir/tracked-file1").unwrap();
2809            let ignored = tree.entry_for_path("ignored-dir/ignored-file1").unwrap();
2810            assert_eq!(tracked.is_ignored, false);
2811            assert_eq!(ignored.is_ignored, true);
2812        });
2813
2814        std::fs::write(dir.path().join("tracked-dir/tracked-file2"), "").unwrap();
2815        std::fs::write(dir.path().join("ignored-dir/ignored-file2"), "").unwrap();
2816        tree.flush_fs_events(&cx).await;
2817        cx.read(|cx| {
2818            let tree = tree.read(cx);
2819            let dot_git = tree.entry_for_path(".git").unwrap();
2820            let tracked = tree.entry_for_path("tracked-dir/tracked-file2").unwrap();
2821            let ignored = tree.entry_for_path("ignored-dir/ignored-file2").unwrap();
2822            assert_eq!(tracked.is_ignored, false);
2823            assert_eq!(ignored.is_ignored, true);
2824            assert_eq!(dot_git.is_ignored, true);
2825        });
2826    }
2827
2828    #[gpui::test(iterations = 100)]
2829    fn test_random(mut rng: StdRng) {
2830        let operations = env::var("OPERATIONS")
2831            .map(|o| o.parse().unwrap())
2832            .unwrap_or(40);
2833        let initial_entries = env::var("INITIAL_ENTRIES")
2834            .map(|o| o.parse().unwrap())
2835            .unwrap_or(20);
2836
2837        let root_dir = tempdir::TempDir::new("worktree-test").unwrap();
2838        for _ in 0..initial_entries {
2839            randomly_mutate_tree(root_dir.path(), 1.0, &mut rng).unwrap();
2840        }
2841        log::info!("Generated initial tree");
2842
2843        let (notify_tx, _notify_rx) = mpsc::unbounded();
2844        let fs = Arc::new(RealFs);
2845        let next_entry_id = Arc::new(AtomicUsize::new(0));
2846        let mut initial_snapshot = LocalSnapshot {
2847            abs_path: root_dir.path().into(),
2848            removed_entry_ids: Default::default(),
2849            ignores: Default::default(),
2850            next_entry_id: next_entry_id.clone(),
2851            snapshot: Snapshot {
2852                id: WorktreeId::from_usize(0),
2853                entries_by_path: Default::default(),
2854                entries_by_id: Default::default(),
2855                root_name: Default::default(),
2856                root_char_bag: Default::default(),
2857                scan_id: 0,
2858            },
2859        };
2860        initial_snapshot.insert_entry(
2861            Entry::new(
2862                Path::new("").into(),
2863                &smol::block_on(fs.metadata(root_dir.path()))
2864                    .unwrap()
2865                    .unwrap(),
2866                &next_entry_id,
2867                Default::default(),
2868            ),
2869            fs.as_ref(),
2870        );
2871        let mut scanner = BackgroundScanner::new(
2872            Arc::new(Mutex::new(initial_snapshot.clone())),
2873            notify_tx,
2874            fs.clone(),
2875            Arc::new(gpui::executor::Background::new()),
2876        );
2877        smol::block_on(scanner.scan_dirs()).unwrap();
2878        scanner.snapshot().check_invariants();
2879
2880        let mut events = Vec::new();
2881        let mut snapshots = Vec::new();
2882        let mut mutations_len = operations;
2883        while mutations_len > 1 {
2884            if !events.is_empty() && rng.gen_bool(0.4) {
2885                let len = rng.gen_range(0..=events.len());
2886                let to_deliver = events.drain(0..len).collect::<Vec<_>>();
2887                log::info!("Delivering events: {:#?}", to_deliver);
2888                smol::block_on(scanner.process_events(to_deliver));
2889                scanner.snapshot().check_invariants();
2890            } else {
2891                events.extend(randomly_mutate_tree(root_dir.path(), 0.6, &mut rng).unwrap());
2892                mutations_len -= 1;
2893            }
2894
2895            if rng.gen_bool(0.2) {
2896                snapshots.push(scanner.snapshot());
2897            }
2898        }
2899        log::info!("Quiescing: {:#?}", events);
2900        smol::block_on(scanner.process_events(events));
2901        scanner.snapshot().check_invariants();
2902
2903        let (notify_tx, _notify_rx) = mpsc::unbounded();
2904        let mut new_scanner = BackgroundScanner::new(
2905            Arc::new(Mutex::new(initial_snapshot)),
2906            notify_tx,
2907            scanner.fs.clone(),
2908            scanner.executor.clone(),
2909        );
2910        smol::block_on(new_scanner.scan_dirs()).unwrap();
2911        assert_eq!(
2912            scanner.snapshot().to_vec(true),
2913            new_scanner.snapshot().to_vec(true)
2914        );
2915
2916        for mut prev_snapshot in snapshots {
2917            let include_ignored = rng.gen::<bool>();
2918            if !include_ignored {
2919                let mut entries_by_path_edits = Vec::new();
2920                let mut entries_by_id_edits = Vec::new();
2921                for entry in prev_snapshot
2922                    .entries_by_id
2923                    .cursor::<()>()
2924                    .filter(|e| e.is_ignored)
2925                {
2926                    entries_by_path_edits.push(Edit::Remove(PathKey(entry.path.clone())));
2927                    entries_by_id_edits.push(Edit::Remove(entry.id));
2928                }
2929
2930                prev_snapshot
2931                    .entries_by_path
2932                    .edit(entries_by_path_edits, &());
2933                prev_snapshot.entries_by_id.edit(entries_by_id_edits, &());
2934            }
2935
2936            let update = scanner
2937                .snapshot()
2938                .build_update(&prev_snapshot, 0, 0, include_ignored);
2939            prev_snapshot.apply_remote_update(update).unwrap();
2940            assert_eq!(
2941                prev_snapshot.to_vec(true),
2942                scanner.snapshot().to_vec(include_ignored)
2943            );
2944        }
2945    }
2946
2947    fn randomly_mutate_tree(
2948        root_path: &Path,
2949        insertion_probability: f64,
2950        rng: &mut impl Rng,
2951    ) -> Result<Vec<fsevent::Event>> {
2952        let root_path = root_path.canonicalize().unwrap();
2953        let (dirs, files) = read_dir_recursive(root_path.clone());
2954
2955        let mut events = Vec::new();
2956        let mut record_event = |path: PathBuf| {
2957            events.push(fsevent::Event {
2958                event_id: SystemTime::now()
2959                    .duration_since(UNIX_EPOCH)
2960                    .unwrap()
2961                    .as_secs(),
2962                flags: fsevent::StreamFlags::empty(),
2963                path,
2964            });
2965        };
2966
2967        if (files.is_empty() && dirs.len() == 1) || rng.gen_bool(insertion_probability) {
2968            let path = dirs.choose(rng).unwrap();
2969            let new_path = path.join(gen_name(rng));
2970
2971            if rng.gen() {
2972                log::info!("Creating dir {:?}", new_path.strip_prefix(root_path)?);
2973                std::fs::create_dir(&new_path)?;
2974            } else {
2975                log::info!("Creating file {:?}", new_path.strip_prefix(root_path)?);
2976                std::fs::write(&new_path, "")?;
2977            }
2978            record_event(new_path);
2979        } else if rng.gen_bool(0.05) {
2980            let ignore_dir_path = dirs.choose(rng).unwrap();
2981            let ignore_path = ignore_dir_path.join(&*GITIGNORE);
2982
2983            let (subdirs, subfiles) = read_dir_recursive(ignore_dir_path.clone());
2984            let files_to_ignore = {
2985                let len = rng.gen_range(0..=subfiles.len());
2986                subfiles.choose_multiple(rng, len)
2987            };
2988            let dirs_to_ignore = {
2989                let len = rng.gen_range(0..subdirs.len());
2990                subdirs.choose_multiple(rng, len)
2991            };
2992
2993            let mut ignore_contents = String::new();
2994            for path_to_ignore in files_to_ignore.chain(dirs_to_ignore) {
2995                write!(
2996                    ignore_contents,
2997                    "{}\n",
2998                    path_to_ignore
2999                        .strip_prefix(&ignore_dir_path)?
3000                        .to_str()
3001                        .unwrap()
3002                )
3003                .unwrap();
3004            }
3005            log::info!(
3006                "Creating {:?} with contents:\n{}",
3007                ignore_path.strip_prefix(&root_path)?,
3008                ignore_contents
3009            );
3010            std::fs::write(&ignore_path, ignore_contents).unwrap();
3011            record_event(ignore_path);
3012        } else {
3013            let old_path = {
3014                let file_path = files.choose(rng);
3015                let dir_path = dirs[1..].choose(rng);
3016                file_path.into_iter().chain(dir_path).choose(rng).unwrap()
3017            };
3018
3019            let is_rename = rng.gen();
3020            if is_rename {
3021                let new_path_parent = dirs
3022                    .iter()
3023                    .filter(|d| !d.starts_with(old_path))
3024                    .choose(rng)
3025                    .unwrap();
3026
3027                let overwrite_existing_dir =
3028                    !old_path.starts_with(&new_path_parent) && rng.gen_bool(0.3);
3029                let new_path = if overwrite_existing_dir {
3030                    std::fs::remove_dir_all(&new_path_parent).ok();
3031                    new_path_parent.to_path_buf()
3032                } else {
3033                    new_path_parent.join(gen_name(rng))
3034                };
3035
3036                log::info!(
3037                    "Renaming {:?} to {}{:?}",
3038                    old_path.strip_prefix(&root_path)?,
3039                    if overwrite_existing_dir {
3040                        "overwrite "
3041                    } else {
3042                        ""
3043                    },
3044                    new_path.strip_prefix(&root_path)?
3045                );
3046                std::fs::rename(&old_path, &new_path)?;
3047                record_event(old_path.clone());
3048                record_event(new_path);
3049            } else if old_path.is_dir() {
3050                let (dirs, files) = read_dir_recursive(old_path.clone());
3051
3052                log::info!("Deleting dir {:?}", old_path.strip_prefix(&root_path)?);
3053                std::fs::remove_dir_all(&old_path).unwrap();
3054                for file in files {
3055                    record_event(file);
3056                }
3057                for dir in dirs {
3058                    record_event(dir);
3059                }
3060            } else {
3061                log::info!("Deleting file {:?}", old_path.strip_prefix(&root_path)?);
3062                std::fs::remove_file(old_path).unwrap();
3063                record_event(old_path.clone());
3064            }
3065        }
3066
3067        Ok(events)
3068    }
3069
3070    fn read_dir_recursive(path: PathBuf) -> (Vec<PathBuf>, Vec<PathBuf>) {
3071        let child_entries = std::fs::read_dir(&path).unwrap();
3072        let mut dirs = vec![path];
3073        let mut files = Vec::new();
3074        for child_entry in child_entries {
3075            let child_path = child_entry.unwrap().path();
3076            if child_path.is_dir() {
3077                let (child_dirs, child_files) = read_dir_recursive(child_path);
3078                dirs.extend(child_dirs);
3079                files.extend(child_files);
3080            } else {
3081                files.push(child_path);
3082            }
3083        }
3084        (dirs, files)
3085    }
3086
3087    fn gen_name(rng: &mut impl Rng) -> String {
3088        (0..6)
3089            .map(|_| rng.sample(rand::distributions::Alphanumeric))
3090            .map(char::from)
3091            .collect()
3092    }
3093
3094    impl LocalSnapshot {
3095        fn check_invariants(&self) {
3096            let mut files = self.files(true, 0);
3097            let mut visible_files = self.files(false, 0);
3098            for entry in self.entries_by_path.cursor::<()>() {
3099                if entry.is_file() {
3100                    assert_eq!(files.next().unwrap().inode, entry.inode);
3101                    if !entry.is_ignored {
3102                        assert_eq!(visible_files.next().unwrap().inode, entry.inode);
3103                    }
3104                }
3105            }
3106            assert!(files.next().is_none());
3107            assert!(visible_files.next().is_none());
3108
3109            let mut bfs_paths = Vec::new();
3110            let mut stack = vec![Path::new("")];
3111            while let Some(path) = stack.pop() {
3112                bfs_paths.push(path);
3113                let ix = stack.len();
3114                for child_entry in self.child_entries(path) {
3115                    stack.insert(ix, &child_entry.path);
3116                }
3117            }
3118
3119            let dfs_paths_via_iter = self
3120                .entries_by_path
3121                .cursor::<()>()
3122                .map(|e| e.path.as_ref())
3123                .collect::<Vec<_>>();
3124            assert_eq!(bfs_paths, dfs_paths_via_iter);
3125
3126            let dfs_paths_via_traversal = self
3127                .entries(true)
3128                .map(|e| e.path.as_ref())
3129                .collect::<Vec<_>>();
3130            assert_eq!(dfs_paths_via_traversal, dfs_paths_via_iter);
3131
3132            for (ignore_parent_path, _) in &self.ignores {
3133                assert!(self.entry_for_path(ignore_parent_path).is_some());
3134                assert!(self
3135                    .entry_for_path(ignore_parent_path.join(&*GITIGNORE))
3136                    .is_some());
3137            }
3138        }
3139
3140        fn to_vec(&self, include_ignored: bool) -> Vec<(&Path, u64, bool)> {
3141            let mut paths = Vec::new();
3142            for entry in self.entries_by_path.cursor::<()>() {
3143                if include_ignored || !entry.is_ignored {
3144                    paths.push((entry.path.as_ref(), entry.inode, entry.is_ignored));
3145                }
3146            }
3147            paths.sort_by(|a, b| a.0.cmp(&b.0));
3148            paths
3149        }
3150    }
3151}