@opensumi/ide-file-service 3.7.2-next-1740450374.0 → 3.7.2-next-1741226843.0

package/src/node/hosted/recursive/file-service-watcher.ts

@@ -1,18 +1,10 @@
-import { tmpdir } from 'os';
-import paths, { join } from 'path';
+import paths from 'path';
 
 import ParcelWatcher from '@parcel/watcher';
 import fs from 'fs-extra';
 import debounce from 'lodash/debounce';
 import uniqBy from 'lodash/uniqBy';
 
-import {
-  FileChangeType,
-  FileSystemWatcherClient,
-  IWatcher,
-  RecursiveWatcherBackend,
-  WatchOptions,
-} from '@opensumi/ide-core-common';
 import { ILogService } from '@opensumi/ide-core-common/lib/log';
 import {
   Disposable,
@@ -20,13 +12,18 @@ import {
   FileUri,
   IDisposable,
   ParsedPattern,
-  RunOnceScheduler,
   isLinux,
   isWindows,
   parseGlob,
 } from '@opensumi/ide-core-common/lib/utils';
 
-import { INsfw } from '../../../common/watcher';
+import {
+  FileChangeType,
+  FileSystemWatcherClient,
+  IFileSystemWatcherServer,
+  INsfw,
+  WatchOptions,
+} from '../../../common';
 import { FileChangeCollection } from '../../file-change-collection';
 import { shouldIgnorePath } from '../shared';
 
@@ -35,6 +32,13 @@ export interface WatcherOptions {
   excludes: string[];
 }
 
+const watcherPlaceHolder = {
+  disposable: {
+    dispose: () => {},
+  },
+  handlers: [],
+};
+
 /**
  * @deprecated
  */
@@ -44,27 +48,21 @@ export interface NsfwFileSystemWatcherOption {
   error?: (message: string, ...args: any[]) => void;
 }
 
-export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
+export class FileSystemWatcherServer extends Disposable implements IFileSystemWatcherServer {
   private static readonly PARCEL_WATCHER_BACKEND = isWindows ? 'windows' : isLinux ? 'inotify' : 'fs-events';
 
-  private static DEFAULT_POLLING_INTERVAL = 100;
-
   private WATCHER_HANDLERS = new Map<
-    string,
+    number,
     { path: string; handlers: ParcelWatcher.SubscribeCallback[]; disposable: IDisposable }
   >();
-
-  protected watcherOptions = new Map<string, WatcherOptions>();
+  private static WATCHER_SEQUENCE = 1;
+  protected watcherOptions = new Map<number, WatcherOptions>();
 
   protected client: FileSystemWatcherClient | undefined;
 
   protected changes = new FileChangeCollection();
 
-  constructor(
-    private excludes: string[] = [],
-    private readonly logger: ILogService,
-    private backend: RecursiveWatcherBackend = RecursiveWatcherBackend.NSFW,
-  ) {
+  constructor(private excludes: string[] = [], private readonly logger: ILogService) {
     super();
     this.addDispose(
       Disposable.create(() => {
@@ -73,41 +71,37 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
     );
   }
 
+  /**
+   * 查找某个路径是否已被监听
+   * @param watcherPath
+   */
+  checkIsAlreadyWatched(watcherPath: string): number | undefined {
+    for (const [watcherId, watcher] of this.WATCHER_HANDLERS) {
+      if (watcherPath.indexOf(watcher.path) === 0) {
+        return watcherId;
+      }
+    }
+  }
+
   /**
    * 如果监听路径不存在，则会监听父目录
    * @param uri 要监听的路径
    * @param options
    * @returns
    */
-  async watchFileChanges(uri: string, options?: WatchOptions) {
-    return new Promise<void>((resolve, rej) => {
-      const timer = setTimeout(() => {
-        rej(`Watch ${uri} Timeout`);
-        // FIXME：暂时写死3秒
-      }, 3000);
-
-      if (options?.excludes) {
-        this.updateWatcherFileExcludes(options.excludes);
-      }
-
-      this.doWatchFileChange(uri, options).then(() => {
-        resolve(void 0);
-        if (timer) {
-          clearTimeout(timer);
-        }
-      });
-    });
-  }
+  async watchFileChanges(uri: string, options?: WatchOptions): Promise<number> {
+    const basePath = FileUri.fsPath(uri);
 
-  private async doWatchFileChange(uri: string, options?: WatchOptions) {
-    if (this.WATCHER_HANDLERS.has(uri)) {
-      const handler = this.WATCHER_HANDLERS.get(uri);
-      handler?.disposable.dispose();
-      this.WATCHER_HANDLERS.delete(uri);
+    let watcherId = this.checkIsAlreadyWatched(basePath);
+    if (watcherId) {
+      return watcherId;
     }
 
-    const basePath = FileUri.fsPath(uri);
-    this.logger.log('[Recursive] watch file changes: ', uri);
+    watcherId = FileSystemWatcherServer.WATCHER_SEQUENCE++;
+    this.WATCHER_HANDLERS.set(watcherId, {
+      ...watcherPlaceHolder,
+      path: basePath,
+    });
 
     const toDisposeWatcher = new DisposableCollection();
     let watchPath: string;
@@ -123,10 +117,10 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
     } else {
       watchPath = await this.lookup(basePath);
     }
-
+    this.logger.log('Starting watching:', watchPath, options);
     const handler = (err, events: ParcelWatcher.Event[]) => {
       if (err) {
-        this.logger.error(`[Recursive] Watching ${watchPath} error: `, err);
+        this.logger.error(`Watching ${watchPath} error: `, err);
         return;
       }
       events = this.trimChangeEvent(events);
@@ -145,15 +139,15 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
       }
     };
 
-    this.WATCHER_HANDLERS.set(watchPath, {
+    this.WATCHER_HANDLERS.set(watcherId, {
       path: watchPath,
       disposable: toDisposeWatcher,
       handlers: [handler],
     });
-
-    toDisposeWatcher.push(Disposable.create(() => this.WATCHER_HANDLERS.delete(watchPath)));
-    toDisposeWatcher.push(await this.start(watchPath, options));
+    toDisposeWatcher.push(Disposable.create(() => this.WATCHER_HANDLERS.delete(watcherId as number)));
+    toDisposeWatcher.push(await this.start(watcherId, watchPath, options));
     this.addDispose(toDisposeWatcher);
+    return watcherId;
   }
 
   /**
@@ -190,63 +184,16 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
     this.excludes = excludes;
   }
 
-  protected async start(basePath: string, rawOptions: WatchOptions | undefined): Promise<DisposableCollection> {
-    this.logger.log('[Recursive] Start watching', basePath);
-
+  protected async start(
+    watcherId: number,
+    basePath: string,
+    rawOptions: WatchOptions | undefined,
+  ): Promise<DisposableCollection> {
+    const disposables = new DisposableCollection();
     if (!(await fs.pathExists(basePath))) {
-      return new DisposableCollection();
+      return disposables;
     }
-
     const realPath = await fs.realpath(basePath);
-
-    if (this.isEnableNSFW()) {
-      return this.watchWithNsfw(realPath, rawOptions);
-    } else {
-      // polling
-      if (rawOptions?.pollingWatch) {
-        this.logger.log('[Recursive] Start polling watch:', realPath);
-        return this.pollingWatch(realPath, rawOptions);
-      }
-
-      return this.watchWithParcel(realPath, rawOptions);
-    }
-  }
-
-  private async watchWithNsfw(realPath: string, rawOptions?: WatchOptions | undefined) {
-    const disposables = new DisposableCollection();
-    const nsfw = await this.withNSFWModule();
-    const watcher: INsfw.NSFW = await nsfw(
-      realPath,
-      (events: INsfw.ChangeEvent[]) => this.handleNSFWEvents(events, realPath),
-      {
-        errorCallback: (err) => {
-          this.logger.error('[Recursive] NSFW watcher encountered an error and will stop watching.', err);
-          // see https://github.com/atom/github/issues/342
-          this.unwatchFileChanges(realPath);
-        },
-      },
-    );
-
-    await watcher.start();
-
-    disposables.push(
-      Disposable.create(async () => {
-        this.watcherOptions.delete(realPath);
-        await watcher.stop();
-      }),
-    );
-
-    const excludes = this.excludes.concat(rawOptions?.excludes || []);
-
-    this.watcherOptions.set(realPath, {
-      excludesPattern: excludes.map((pattern) => parseGlob(pattern)),
-      excludes,
-    });
-    return disposables;
-  }
-
-  private async watchWithParcel(realPath: string, rawOptions?: WatchOptions | undefined) {
-    const disposables = new DisposableCollection();
     const tryWatchDir = async (maxRetries = 3, retryDelay = 1000) => {
       for (let times = 0; times < maxRetries; times++) {
         try {
@@ -258,30 +205,23 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
                 // FIXME: 研究此处屏蔽的影响，考虑下阈值应该设置多少，或者更加优雅的方式
                 return;
               }
-              const handlers = this.WATCHER_HANDLERS.get(realPath)?.handlers;
+              const handlers = this.WATCHER_HANDLERS.get(watcherId)?.handlers;
 
               if (!handlers) {
-                this.logger.log('[Recursive] No handler found for watcher', realPath);
                 return;
               }
-
-              this.logger.log('[Recursive] Received events:', events);
-              if (events.length === 0) {
-                return;
-              }
-
               for (const handler of handlers) {
                 (handler as ParcelWatcher.SubscribeCallback)(err, events);
               }
             },
             {
-              backend: RecursiveFileSystemWatcher.PARCEL_WATCHER_BACKEND,
+              backend: FileSystemWatcherServer.PARCEL_WATCHER_BACKEND,
               ignore: this.excludes.concat(rawOptions?.excludes ?? []),
             },
           );
         } catch (e) {
           // Watcher 启动失败，尝试重试
-          this.logger.error('[Recursive] watcher subscribe failed ', e, ' try times ', times);
+          this.logger.error('watcher subscribe failed ', e, ' try times ', times);
           await new Promise((resolve) => {
             setTimeout(resolve, retryDelay);
           });
@@ -289,84 +229,64 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
       }
 
       // 经过若干次的尝试后，Parcel Watcher 依然启动失败，此时就不再尝试重试
-      this.logger.error(`[Recursive] watcher subscribe finally failed after ${maxRetries} times`);
+      this.logger.error(`watcher subscribe finally failed after ${maxRetries} times`);
       return undefined; // watch 失败则返回 undefined
     };
 
-    const hanlder: ParcelWatcher.AsyncSubscription | undefined = await tryWatchDir();
+    if (this.isEnableNSFW()) {
+      const nsfw = await this.withNSFWModule();
+      const watcher: INsfw.NSFW = await nsfw(
+        realPath,
+        (events: INsfw.ChangeEvent[]) => this.handleNSFWEvents(events, watcherId),
+        {
+          errorCallback: (err) => {
+            this.logger.error('NSFW watcher encountered an error and will stop watching.', err);
+            // see https://github.com/atom/github/issues/342
+            this.unwatchFileChanges(watcherId);
+          },
+        },
+      );
+
+      await watcher.start();
 
-    if (hanlder) {
-      // watch 成功才加入 disposables，否则也就无需 dispose
       disposables.push(
         Disposable.create(async () => {
-          if (hanlder) {
-            await hanlder.unsubscribe();
-          }
+          this.watcherOptions.delete(watcherId);
+          await watcher.stop();
         }),
       );
-    }
 
-    return disposables;
-  }
-
-  private async pollingWatch(realPath: string, rawOptions?: WatchOptions | undefined) {
-    const disposables = new DisposableCollection();
-    const snapshotFile = join(tmpdir(), `watcher-snapshot-${realPath}`);
-    let counter = 0;
-
-    const pollingWatcher = new RunOnceScheduler(async () => {
-      counter++;
-      if (counter > 1) {
-        const parcelEvents = await ParcelWatcher.getEventsSince(realPath, snapshotFile, {
-          ignore: rawOptions?.excludes,
-          backend: RecursiveFileSystemWatcher.PARCEL_WATCHER_BACKEND,
-        });
-
-        const handlers = this.WATCHER_HANDLERS.get(realPath)?.handlers;
-
-        if (!handlers) {
-          this.logger.log('[Recursive] No handler found for watcher', realPath);
-          return;
-        }
-
-        this.logger.log('[Recursive] Received events:', parcelEvents);
-        for (const handler of handlers) {
-          (handler as ParcelWatcher.SubscribeCallback)(null, parcelEvents);
-        }
-      }
+      const excludes = this.excludes.concat(rawOptions?.excludes || []);
 
-      await ParcelWatcher.writeSnapshot(realPath, snapshotFile, {
-        ignore: rawOptions?.excludes,
-        backend: RecursiveFileSystemWatcher.PARCEL_WATCHER_BACKEND,
+      this.watcherOptions.set(watcherId, {
+        excludesPattern: excludes.map((pattern) => parseGlob(pattern)),
+        excludes,
       });
-
-      pollingWatcher.schedule();
-    }, RecursiveFileSystemWatcher.DEFAULT_POLLING_INTERVAL);
-
-    pollingWatcher.schedule(0);
-
-    disposables.push(pollingWatcher);
+    } else {
+      const hanlder: ParcelWatcher.AsyncSubscription | undefined = await tryWatchDir();
+
+      if (hanlder) {
+        // watch 成功才加入 disposables，否则也就无需 dispose
+        disposables.push(
+          Disposable.create(async () => {
+            if (hanlder) {
+              await hanlder.unsubscribe();
+            }
+          }),
+        );
+      }
+    }
 
     return disposables;
   }
 
-  private disposeWatcher(path: string) {
-    const watcher = this.WATCHER_HANDLERS.get(path);
+  unwatchFileChanges(watcherId: number): Promise<void> {
+    const watcher = this.WATCHER_HANDLERS.get(watcherId);
     if (watcher) {
-      try {
-        watcher.disposable.dispose();
-      } catch (err) {
-        this.logger.error(`Dispose watcher failed for ${path}`, err);
-      } finally {
-        this.WATCHER_HANDLERS.delete(path);
-      }
+      this.WATCHER_HANDLERS.delete(watcherId);
+      watcher.disposable.dispose();
     }
-  }
-
-  unwatchFileChanges(uri: string): void {
-    this.logger.log('[Recursive] Un watch: ', uri);
-    const basePath = FileUri.fsPath(uri);
-    this.disposeWatcher(basePath);
+    return Promise.resolve();
   }
 
   setClient(client: FileSystemWatcherClient | undefined) {
@@ -381,22 +301,20 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
    * 社区相关 issue: https://github.com/parcel-bundler/watcher/issues/49
    */
   private isEnableNSFW(): boolean {
-    return this.backend === RecursiveWatcherBackend.NSFW || isLinux;
+    return isLinux;
   }
 
-  private async handleNSFWEvents(events: INsfw.ChangeEvent[], realPath: string): Promise<void> {
+  private async handleNSFWEvents(events: INsfw.ChangeEvent[], watcherId: number): Promise<void> {
     if (events.length > 5000) {
       return;
     }
 
-    const isIgnored = (realPath: string, path: string): boolean => {
-      const options = this.watcherOptions.get(realPath);
+    const isIgnored = (watcherId: number, path: string): boolean => {
+      const options = this.watcherOptions.get(watcherId);
       if (!options || !options.excludes || options.excludes.length < 1) {
         return false;
       }
-
-      const excludesPattern = [...this.excludes.map((pattern) => parseGlob(pattern)), ...options.excludesPattern];
-      return excludesPattern.some((match) => match(path));
+      return options.excludesPattern.some((match) => match(path));
     };
 
     const filterEvents = events.filter((event) => {
@@ -424,7 +342,7 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
           case INsfw.actions.RENAMED:
             {
               const deletedPath = await this.resolvePath(event.directory, event.oldFile!);
-              if (isIgnored(realPath, deletedPath)) {
+              if (isIgnored(watcherId, deletedPath)) {
                 return;
               }
 
@@ -432,14 +350,14 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
 
               if (event.newDirectory) {
                 const path = await this.resolvePath(event.newDirectory, event.newFile!);
-                if (isIgnored(realPath, path)) {
+                if (isIgnored(watcherId, path)) {
                   return;
                 }
 
                 this.pushAdded(path);
               } else {
                 const path = await this.resolvePath(event.directory, event.newFile!);
-                if (isIgnored(realPath, path)) {
+                if (isIgnored(watcherId, path)) {
                   return;
                 }
 
@@ -450,7 +368,7 @@ export class RecursiveFileSystemWatcher extends Disposable implements IWatcher {
           default:
             {
               const path = await this.resolvePath(event.directory, event.file!);
-              if (isIgnored(realPath, path)) {
+              if (isIgnored(watcherId, path)) {
                 return;
               }
 

package/src/node/hosted/un-recursive/file-service-watcher.ts

@@ -2,15 +2,24 @@ import fs, { watch } from 'fs-extra';
 import debounce from 'lodash/debounce';
 
 import { ILogService } from '@opensumi/ide-core-common/lib/log';
-import { Disposable, DisposableCollection, FileUri, isMacintosh, path } from '@opensumi/ide-utils/lib';
+import { Disposable, DisposableCollection, FileUri, IDisposable, isMacintosh, path } from '@opensumi/ide-utils/lib';
 
-import { FileChangeType, FileSystemWatcherClient, IWatcher } from '../../../common/index';
+import { FileChangeType, FileSystemWatcherClient, IFileSystemWatcherServer } from '../../../common/index';
 import { FileChangeCollection } from '../../file-change-collection';
 import { shouldIgnorePath } from '../shared';
 const { join, basename, normalize } = path;
 
-export class UnRecursiveFileSystemWatcher implements IWatcher {
-  private watcherCollections: Map<string, fs.FSWatcher> = new Map();
+export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
+  private WATCHER_HANDLERS = new Map<
+    number,
+    {
+      path: string;
+      handlers: any;
+      disposable: IDisposable;
+    }
+  >();
+
+  private static WATCHER_SEQUENCE = 1;
 
   private static readonly FILE_DELETE_HANDLER_DELAY = 500;
 
@@ -25,12 +34,25 @@ export class UnRecursiveFileSystemWatcher implements IWatcher {
 
   dispose(): void {
     this.toDispose.dispose();
+    this.WATCHER_HANDLERS.clear();
+  }
+
+  /**
+   * 查找某个路径是否已被监听
+   * @param watcherPath
+   */
+  checkIsAlreadyWatched(watcherPath: string): number | undefined {
+    for (const [watcherId, watcher] of this.WATCHER_HANDLERS) {
+      if (watcherPath.indexOf(watcher.path) === 0) {
+        return watcherId;
+      }
+    }
   }
 
   private async doWatch(basePath: string) {
     try {
       const watcher = watch(basePath);
-      this.logger.log('[Un-Recursive] start watching', basePath);
+      this.logger.log('start watching', basePath);
       const isDirectory = fs.lstatSync(basePath).isDirectory();
 
       const docChildren = new Set<string>();
@@ -52,9 +74,7 @@ export class UnRecursiveFileSystemWatcher implements IWatcher {
 
       // 开始走监听流程
       watcher.on('error', (code: number, signal: string) => {
-        this.logger.error(
-          `[Un-Recursive] Failed to watch ${basePath} for changes using fs.watch() (${code}, ${signal})`,
-        );
+        this.logger.error(`Failed to watch ${basePath} for changes using fs.watch() (${code}, ${signal})`);
         watcher.close();
       });
 
@@ -110,7 +130,7 @@ export class UnRecursiveFileSystemWatcher implements IWatcher {
         }
       });
     } catch (error) {
-      this.logger.error(`[Un-Recursive] Failed to watch ${basePath} for change using fs.watch() (${error.toString()})`);
+      this.logger.error(`Failed to watch ${basePath} for change using fs.watch() (${error.toString()})`);
     }
   }
 
@@ -118,20 +138,29 @@ export class UnRecursiveFileSystemWatcher implements IWatcher {
     const basePath = FileUri.fsPath(uri);
     const exist = await fs.pathExists(basePath);
 
+    let watcherId = this.checkIsAlreadyWatched(basePath);
+
+    if (watcherId) {
+      return watcherId;
+    }
+
+    watcherId = UnRecursiveFileSystemWatcher.WATCHER_SEQUENCE++;
+
     const disposables = new DisposableCollection(); // 管理可释放的资源
 
     let watchPath = '';
 
     if (exist) {
-      const stat = await fs.lstat(basePath);
+      const stat = await fs.lstatSync(basePath);
       if (stat) {
         watchPath = basePath;
       }
     } else {
-      this.logger.warn('[Un-Recursive] This path does not exist. Please try again');
+      this.logger.warn('This path does not exist. Please try again');
     }
     disposables.push(await this.start(watchPath));
     this.toDispose.push(disposables);
+    return watcherId;
   }
 
   protected async start(basePath: string): Promise<DisposableCollection> {
@@ -141,10 +170,6 @@ export class UnRecursiveFileSystemWatcher implements IWatcher {
     }
 
     const realPath = await fs.realpath(basePath);
-    if (this.watcherCollections.has(realPath)) {
-      return disposables;
-    }
-
     const tryWatchDir = async (retryDelay = 1000) => {
       try {
         this.doWatch(realPath);
@@ -158,14 +183,13 @@ export class UnRecursiveFileSystemWatcher implements IWatcher {
     await tryWatchDir();
     return disposables;
   }
-
-  unwatchFileChanges(uri: string): void {
-    const basePath = FileUri.fsPath(uri);
-    if (this.watcherCollections.has(basePath)) {
-      const watcher = this.watcherCollections.get(basePath);
-      watcher?.close();
-      this.watcherCollections.delete(basePath);
+  unwatchFileChanges(watcherId: number): Promise<void> {
+    const watcher = this.WATCHER_HANDLERS.get(watcherId);
+    if (watcher) {
+      this.WATCHER_HANDLERS.delete(watcherId);
+      watcher.disposable.dispose();
     }
+    return Promise.resolve();
   }
 
   protected pushAdded(path: string): void {