@opensumi/ide-file-service 3.7.1-next-1736826301.0 → 3.7.1-next-1736846464.0

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

@@ -2,24 +2,15 @@ import fs, { watch } from 'fs-extra';
 import debounce from 'lodash/debounce';
 
 import { ILogService } from '@opensumi/ide-core-common/lib/log';
-import { Disposable, DisposableCollection, FileUri, IDisposable, isMacintosh, path } from '@opensumi/ide-utils/lib';
+import { Disposable, DisposableCollection, FileUri, isMacintosh, path } from '@opensumi/ide-utils/lib';
 
-import { FileChangeType, FileSystemWatcherClient, IFileSystemWatcherServer } from '../../../common/index';
+import { FileChangeType, FileSystemWatcherClient, IWatcher } from '../../../common/index';
 import { FileChangeCollection } from '../../file-change-collection';
 import { shouldIgnorePath } from '../shared';
 const { join, basename, normalize } = path;
 
-export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
-  private WATCHER_HANDLERS = new Map<
-    number,
-    {
-      path: string;
-      handlers: any;
-      disposable: IDisposable;
-    }
-  >();
-
-  private static WATCHER_SEQUENCE = 1;
+export class UnRecursiveFileSystemWatcher implements IWatcher {
+  private watcherCollections: Map<string, fs.FSWatcher> = new Map();
 
   private static readonly FILE_DELETE_HANDLER_DELAY = 500;
 
@@ -34,34 +25,25 @@ export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
 
   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('start watching', basePath);
-      const isDirectory = fs.lstatSync(basePath).isDirectory();
+      this.watcherCollections.set(basePath, watcher);
+
+      this.logger.log('[Un-Recursive] start watching', basePath);
+      const isDirectory = (await fs.lstat(basePath)).isDirectory();
 
       const docChildren = new Set<string>();
       let signalDoc = '';
       if (isDirectory) {
         try {
-          for (const child of fs.readdirSync(basePath)) {
+          const children = await fs.readdir(basePath);
+          for (const child of children) {
             const base = join(basePath, String(child));
-            if (!fs.lstatSync(base).isDirectory()) {
+            const childStat = await fs.lstat(base);
+            if (!childStat.isDirectory()) {
               docChildren.add(child);
             }
           }
@@ -74,11 +56,13 @@ export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
 
       // 开始走监听流程
       watcher.on('error', (code: number, signal: string) => {
-        this.logger.error(`Failed to watch ${basePath} for changes using fs.watch() (${code}, ${signal})`);
+        this.logger.error(
+          `[Un-Recursive] Failed to watch ${basePath} for changes using fs.watch() (${code}, ${signal})`,
+        );
         watcher.close();
       });
 
-      watcher.on('change', (type: string, filename: string | Buffer) => {
+      watcher.on('change', async (type: string, filename: string | Buffer) => {
         if (shouldIgnorePath(filename as string)) {
           return;
         }
@@ -96,21 +80,22 @@ export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
         }
 
         const changePath = join(basePath, changeFileName);
+        const pathExist = await fs.pathExists(changePath);
         if (isDirectory) {
           setTimeout(async () => {
             // 监听的目录如果是文件夹，那么只对其下面的文件改动做出响应
             if (docChildren.has(changeFileName)) {
               if ((type === 'rename' || type === 'change') && changeFileName === filename) {
-                const fileExists = fs.existsSync(changePath);
-                if (fileExists) {
+                if (pathExist) {
                   this.pushUpdated(changePath);
                 } else {
                   docChildren.delete(changeFileName);
                   this.pushDeleted(changePath);
                 }
               }
-            } else if (fs.pathExistsSync(changePath)) {
-              if (!fs.lstatSync(changePath).isDirectory()) {
+            } else if (pathExist) {
+              const fileStat = await fs.lstat(changePath);
+              if (!fileStat.isDirectory()) {
                 this.pushAdded(changePath);
                 docChildren.add(changeFileName);
               }
@@ -119,7 +104,7 @@ export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
         } else {
           setTimeout(async () => {
             if (changeFileName === signalDoc) {
-              if (fs.pathExistsSync(basePath)) {
+              if (pathExist) {
                 this.pushUpdated(basePath);
               } else {
                 this.pushDeleted(basePath);
@@ -130,7 +115,7 @@ export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
         }
       });
     } catch (error) {
-      this.logger.error(`Failed to watch ${basePath} for change using fs.watch() (${error.toString()})`);
+      this.logger.error(`[Un-Recursive] Failed to watch ${basePath} for change using fs.watch() (${error.toString()})`);
     }
   }
 
@@ -138,29 +123,20 @@ export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
     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.lstatSync(basePath);
+      const stat = await fs.lstat(basePath);
       if (stat) {
         watchPath = basePath;
       }
     } else {
-      this.logger.warn('This path does not exist. Please try again');
+      this.logger.warn('[Un-Recursive] 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> {
@@ -170,6 +146,10 @@ export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
     }
 
     const realPath = await fs.realpath(basePath);
+    if (this.watcherCollections.has(realPath)) {
+      return disposables;
+    }
+
     const tryWatchDir = async (retryDelay = 1000) => {
       try {
         this.doWatch(realPath);
@@ -183,13 +163,14 @@ export class UnRecursiveFileSystemWatcher implements IFileSystemWatcherServer {
     await tryWatchDir();
     return disposables;
   }
-  unwatchFileChanges(watcherId: number): Promise<void> {
-    const watcher = this.WATCHER_HANDLERS.get(watcherId);
-    if (watcher) {
-      this.WATCHER_HANDLERS.delete(watcherId);
-      watcher.disposable.dispose();
+
+  async unwatchFileChanges(uri: string): Promise<void> {
+    const basePath = FileUri.fsPath(uri);
+    if (this.watcherCollections.has(basePath)) {
+      const watcher = this.watcherCollections.get(basePath);
+      watcher?.close();
+      this.watcherCollections.delete(basePath);
     }
-    return Promise.resolve();
   }
 
   protected pushAdded(path: string): void {

package/src/node/hosted/watcher.host.service.ts

@@ -1,20 +1,45 @@
 import { SumiConnectionMultiplexer } from '@opensumi/ide-connection';
-import { DidFilesChangedParams } from '@opensumi/ide-core-common';
+import {
+  DidFilesChangedParams,
+  Disposable,
+  DisposableCollection,
+  FileUri,
+  IDisposable,
+  RecursiveWatcherBackend,
+} from '@opensumi/ide-core-common';
 import { defaultFilesWatcherExcludes, flattenExcludes } from '@opensumi/ide-core-common/lib/preferences/file-watch';
 import { URI, Uri, UriComponents } from '@opensumi/ide-utils/lib/uri';
 
 import { IWatcherHostService, WatcherProcessManagerProxy, WatcherServiceProxy } from '../../common/watcher';
 import { IWatcher } from '../disk-file-system.provider';
 
-import { FileSystemWatcherServer } from './recursive/file-service-watcher';
+import { RecursiveFileSystemWatcher } from './recursive/file-service-watcher';
 import { UnRecursiveFileSystemWatcher } from './un-recursive/file-service-watcher';
 import { WatcherProcessLogger } from './watch-process-log';
 
+const watcherPlaceHolder = {
+  disposable: {
+    dispose: () => { },
+  },
+  handlers: [],
+};
+
 export class WatcherHostServiceImpl implements IWatcherHostService {
+  private static WATCHER_SEQUENCE = 1;
+
+  private WATCHER_HANDLERS = new Map<
+    number,
+    {
+      path: string;
+      handlers: any;
+      disposable: IDisposable;
+    }
+  >();
+
   /**
    * recursive file system watcher
    */
-  private recursiveFileSystemWatcher?: FileSystemWatcherServer;
+  private recursiveFileSystemWatcher?: RecursiveFileSystemWatcher;
 
   /**
    * unrecursive file system watcher
@@ -27,7 +52,11 @@ export class WatcherHostServiceImpl implements IWatcherHostService {
 
   private watchedDirs: Set<string> = new Set();
 
-  constructor(private rpcProtocol: SumiConnectionMultiplexer, private logger: WatcherProcessLogger) {
+  constructor(
+    private rpcProtocol: SumiConnectionMultiplexer,
+    private logger: WatcherProcessLogger,
+    private backend: RecursiveWatcherBackend,
+  ) {
     this.rpcProtocol.set(WatcherServiceProxy, this);
     this.defaultExcludes = flattenExcludes(defaultFilesWatcherExcludes);
     this.initWatcherServer(this.defaultExcludes);
@@ -48,18 +77,18 @@ export class WatcherHostServiceImpl implements IWatcherHostService {
 
       // rewatch
       for (const [_uri, { options, disposable }] of this.watcherCollection) {
-        this.doWatch(Uri.parse(_uri), options);
         this.logger.log('rewatch file changes: ', _uri, ' recursive: ', options?.recursive);
         disposable.dispose();
+        this.doWatch(Uri.parse(_uri), options);
       }
     }
 
-    this.recursiveFileSystemWatcher = new FileSystemWatcherServer(excludes, this.logger);
+    this.recursiveFileSystemWatcher = new RecursiveFileSystemWatcher(excludes, this.logger, this.backend);
     this.unrecursiveFileSystemWatcher = new UnRecursiveFileSystemWatcher(this.logger);
 
     const watcherClient = {
       onDidFilesChanged: (events: DidFilesChangedParams) => {
-        this.logger.log('watcher server onDidFilesChanged: ', events);
+        this.logger.log('onDidFilesChanged: ', events);
         const proxy = this.rpcProtocol.getProxy(WatcherProcessManagerProxy);
         proxy.$onDidFilesChanged(events);
       },
@@ -69,47 +98,80 @@ export class WatcherHostServiceImpl implements IWatcherHostService {
     this.unrecursiveFileSystemWatcher.setClient(watcherClient);
   }
 
-  private getWatcherServer(recursive?: boolean) {
-    const useRecursiveServer = recursive;
-    let watcherServer: FileSystemWatcherServer | UnRecursiveFileSystemWatcher;
+  checkIsAlreadyWatched(watcherPath: string): number | undefined {
+    for (const [watcherId, watcher] of this.WATCHER_HANDLERS) {
+      if (watcherPath === watcher.path) {
+        return watcherId;
+      }
+    }
+  }
+
+  private async doWatch(
+    uri: Uri,
+    options?: { excludes?: string[]; recursive?: boolean; pollingWatch?: boolean },
+  ): Promise<number> {
     this.initWatcherServer();
+    const basePath = FileUri.fsPath(uri.toString());
+    let watcherId = this.checkIsAlreadyWatched(basePath);
 
-    if (useRecursiveServer) {
-      watcherServer = this.recursiveFileSystemWatcher!;
-    } else {
-      watcherServer = this.unrecursiveFileSystemWatcher!;
+    if (watcherId) {
+      this.logger.log(uri.toString(), 'is already watched');
+      return watcherId;
     }
 
-    return watcherServer;
-  }
+    watcherId = WatcherHostServiceImpl.WATCHER_SEQUENCE++;
 
-  private async doWatch(uri: Uri, options?: { excludes?: string[]; recursive?: boolean }): Promise<number> {
-    const watcherServer = this.getWatcherServer(options?.recursive);
-    if (!watcherServer) {
-      return -1;
-    }
+    this.WATCHER_HANDLERS.set(watcherId, {
+      ...watcherPlaceHolder,
+      path: basePath,
+    });
 
     this.logger.log('watch file changes: ', uri.toString(), ' recursive: ', options?.recursive);
 
     const mergedExcludes = new Set([...(options?.excludes ?? []), ...this.defaultExcludes]);
-    const id = await watcherServer.watchFileChanges(uri.toString(), {
-      excludes: Array.from(mergedExcludes),
-    });
 
-    this.watchedDirs.add(uri.toString());
+    const disposables = new DisposableCollection();
 
-    const disposable = {
-      dispose: () => {
-        watcherServer.unwatchFileChanges(id);
+    await this.unrecursiveFileSystemWatcher!.watchFileChanges(uri.toString());
+
+    disposables.push(
+      Disposable.create(() => {
+        this.unrecursiveFileSystemWatcher!.unwatchFileChanges(uri.toString());
         this.watchedDirs.delete(uri.toString());
-      },
-    };
+      }),
+    );
+
+    if (options?.recursive) {
+      this.logger.log('use recursive watcher for: ', uri.toString());
+      try {
+        await this.recursiveFileSystemWatcher!.watchFileChanges(uri.toString(), {
+          excludes: Array.from(mergedExcludes),
+          pollingWatch: options?.pollingWatch,
+        });
+
+        disposables.push(
+          Disposable.create(() => {
+            this.recursiveFileSystemWatcher!.unwatchFileChanges(uri.toString());
+            this.watchedDirs.delete(uri.toString());
+          }),
+        );
+      } catch (error) {
+        // watch error or timeout
+        this.logger.error('watch error: ', error);
+      }
+    }
+
+    this.watcherCollection.set(uri.toString(), { id: watcherId, options, disposable: disposables });
+
+    this.watchedDirs.add(uri.toString());
 
-    this.watcherCollection.set(uri.toString(), { id, options, disposable });
-    return id;
+    return watcherId;
   }
 
-  async $watch(uri: UriComponents, options?: { excludes?: string[]; recursive?: boolean }): Promise<number> {
+  async $watch(
+    uri: UriComponents,
+    options?: { excludes?: string[]; recursive?: boolean; pollingWatch?: boolean },
+  ): Promise<number> {
     const _uri = URI.revive(uri);
     return this.doWatch(_uri, options);
   }

package/src/node/hosted/watcher.process.ts

@@ -37,7 +37,7 @@ async function initWatcherProcess() {
   });
 
   const logger = new WatcherProcessLogger(watcherInjector, initData.logDir, initData.logLevel);
-  const watcherHostService = new WatcherHostServiceImpl(watcherProtocol, logger);
+  const watcherHostService = new WatcherHostServiceImpl(watcherProtocol, logger, initData.backend);
   watcherHostService.initWatcherServer();
 }
 

package/src/node/watcher-process-manager.ts

@@ -7,7 +7,11 @@ import { IRPCProtocol } from '@opensumi/ide-connection';
 import { NetSocketConnection } from '@opensumi/ide-connection/lib/common/connection/drivers/socket';
 import { SumiConnectionMultiplexer } from '@opensumi/ide-connection/lib/common/rpc/multiplexer';
 import { ILogServiceManager, SupportLogNamespace } from '@opensumi/ide-core-common/lib/log';
-import { DidFilesChangedParams, FileSystemWatcherClient } from '@opensumi/ide-core-common/lib/types/file-watch';
+import {
+  DidFilesChangedParams,
+  FileSystemWatcherClient,
+  RecursiveWatcherBackend,
+} from '@opensumi/ide-core-common/lib/types/file-watch';
 import { normalizedIpcHandlerPathAsync } from '@opensumi/ide-core-common/lib/utils/ipc';
 import { AppConfig, Deferred, ILogService, UriComponents } from '@opensumi/ide-core-node';
 import { process as processUtil } from '@opensumi/ide-utils';
@@ -110,7 +114,7 @@ export class WatcherProcessManagerImpl implements IWatcherProcessManager {
     );
   }
 
-  private async createWatcherProcess(clientId: string, ipcHandlerPath: string) {
+  private async createWatcherProcess(clientId: string, ipcHandlerPath: string, backend?: RecursiveWatcherBackend) {
     const forkArgs = [
       `--${SUMI_WATCHER_PROCESS_SOCK_KEY}=${JSON.stringify({
         path: ipcHandlerPath,
@@ -118,6 +122,7 @@ export class WatcherProcessManagerImpl implements IWatcherProcessManager {
       `--${WATCHER_INIT_DATA_KEY}=${JSON.stringify({
         logDir: this.appConfig.logDir,
         logLevel: this.appConfig.logLevel,
+        backend,
         clientId,
       })}`,
     ];
@@ -136,14 +141,14 @@ export class WatcherProcessManagerImpl implements IWatcherProcessManager {
     return this.watcherProcess.pid;
   }
 
-  async createProcess(clientId: string) {
+  async createProcess(clientId: string, backend?: RecursiveWatcherBackend) {
     this.logger.log('create watcher process for client: ', clientId);
     this.logger.log('appconfig watcherHost: ', this.watcherHost);
 
     const ipcHandlerPath = await this.getIPCHandlerPath('watcher_process');
     await this.createWatcherServer(clientId, ipcHandlerPath);
 
-    const pid = await this.createWatcherProcess(clientId, ipcHandlerPath);
+    const pid = await this.createWatcherProcess(clientId, ipcHandlerPath, backend);
 
     return pid;
   }
@@ -158,7 +163,10 @@ export class WatcherProcessManagerImpl implements IWatcherProcessManager {
     }
   }
 
-  async watch(uri: UriComponents, options?: { excludes?: string[]; recursive?: boolean }): Promise<number> {
+  async watch(
+    uri: UriComponents,
+    options?: { excludes?: string[]; recursive?: boolean; pollingWatch: boolean },
+  ): Promise<number> {
     this.logger.log('Wait for watcher process ready...');
     await this._whenReadyDeferred.promise;
     this.logger.log('start watch: ', uri);