@opensumi/ide-file-service 3.7.1-next-1736763672.0 → 3.7.1-next-1736771329.0

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,25 +34,34 @@ 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.watcherCollections.set(basePath, watcher);
-
-      this.logger.log('[Un-Recursive] start watching', basePath);
-      const isDirectory = (await fs.lstat(basePath)).isDirectory();
+      this.logger.log('start watching', basePath);
+      const isDirectory = fs.lstatSync(basePath).isDirectory();
 
       const docChildren = new Set<string>();
       let signalDoc = '';
       if (isDirectory) {
         try {
-          const children = await fs.readdir(basePath);
-          for (const child of children) {
+          for (const child of fs.readdirSync(basePath)) {
             const base = join(basePath, String(child));
-            const childStat = await fs.lstat(base);
-            if (!childStat.isDirectory()) {
+            if (!fs.lstatSync(base).isDirectory()) {
               docChildren.add(child);
             }
           }
@@ -56,13 +74,11 @@ 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();
       });
 
-      watcher.on('change', async (type: string, filename: string | Buffer) => {
+      watcher.on('change', (type: string, filename: string | Buffer) => {
         if (shouldIgnorePath(filename as string)) {
           return;
         }
@@ -80,22 +96,21 @@ export class UnRecursiveFileSystemWatcher implements IWatcher {
         }
 
         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) {
-                if (pathExist) {
+                const fileExists = fs.existsSync(changePath);
+                if (fileExists) {
                   this.pushUpdated(changePath);
                 } else {
                   docChildren.delete(changeFileName);
                   this.pushDeleted(changePath);
                 }
               }
-            } else if (pathExist) {
-              const fileStat = await fs.lstat(changePath);
-              if (!fileStat.isDirectory()) {
+            } else if (fs.pathExistsSync(changePath)) {
+              if (!fs.lstatSync(changePath).isDirectory()) {
                 this.pushAdded(changePath);
                 docChildren.add(changeFileName);
               }
@@ -104,7 +119,7 @@ export class UnRecursiveFileSystemWatcher implements IWatcher {
         } else {
           setTimeout(async () => {
             if (changeFileName === signalDoc) {
-              if (pathExist) {
+              if (fs.pathExistsSync(basePath)) {
                 this.pushUpdated(basePath);
               } else {
                 this.pushDeleted(basePath);
@@ -115,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()})`);
     }
   }
 
@@ -123,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> {
@@ -146,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);
@@ -163,14 +183,13 @@ export class UnRecursiveFileSystemWatcher implements IWatcher {
     await tryWatchDir();
     return disposables;
   }
-
-  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);
+  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 {

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

@@ -1,45 +1,20 @@
 import { SumiConnectionMultiplexer } from '@opensumi/ide-connection';
-import {
-  DidFilesChangedParams,
-  Disposable,
-  DisposableCollection,
-  FileUri,
-  IDisposable,
-  RecursiveWatcherBackend,
-} from '@opensumi/ide-core-common';
+import { DidFilesChangedParams } 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 { RecursiveFileSystemWatcher } from './recursive/file-service-watcher';
+import { FileSystemWatcherServer } 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?: RecursiveFileSystemWatcher;
+  private recursiveFileSystemWatcher?: FileSystemWatcherServer;
 
   /**
    * unrecursive file system watcher
@@ -52,11 +27,7 @@ export class WatcherHostServiceImpl implements IWatcherHostService {
 
   private watchedDirs: Set<string> = new Set();
 
-  constructor(
-    private rpcProtocol: SumiConnectionMultiplexer,
-    private logger: WatcherProcessLogger,
-    private backend: RecursiveWatcherBackend,
-  ) {
+  constructor(private rpcProtocol: SumiConnectionMultiplexer, private logger: WatcherProcessLogger) {
     this.rpcProtocol.set(WatcherServiceProxy, this);
     this.defaultExcludes = flattenExcludes(defaultFilesWatcherExcludes);
     this.initWatcherServer(this.defaultExcludes);
@@ -77,18 +48,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 RecursiveFileSystemWatcher(excludes, this.logger, this.backend);
+    this.recursiveFileSystemWatcher = new FileSystemWatcherServer(excludes, this.logger);
     this.unrecursiveFileSystemWatcher = new UnRecursiveFileSystemWatcher(this.logger);
 
     const watcherClient = {
       onDidFilesChanged: (events: DidFilesChangedParams) => {
-        this.logger.log('onDidFilesChanged: ', events);
+        this.logger.log('watcher server onDidFilesChanged: ', events);
         const proxy = this.rpcProtocol.getProxy(WatcherProcessManagerProxy);
         proxy.$onDidFilesChanged(events);
       },
@@ -98,80 +69,47 @@ export class WatcherHostServiceImpl implements IWatcherHostService {
     this.unrecursiveFileSystemWatcher.setClient(watcherClient);
   }
 
-  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> {
+  private getWatcherServer(recursive?: boolean) {
+    const useRecursiveServer = recursive;
+    let watcherServer: FileSystemWatcherServer | UnRecursiveFileSystemWatcher;
     this.initWatcherServer();
-    const basePath = FileUri.fsPath(uri.toString());
-    let watcherId = this.checkIsAlreadyWatched(basePath);
 
-    if (watcherId) {
-      this.logger.log(uri.toString(), 'is already watched');
-      return watcherId;
+    if (useRecursiveServer) {
+      watcherServer = this.recursiveFileSystemWatcher!;
+    } else {
+      watcherServer = this.unrecursiveFileSystemWatcher!;
     }
 
-    watcherId = WatcherHostServiceImpl.WATCHER_SEQUENCE++;
+    return watcherServer;
+  }
 
-    this.WATCHER_HANDLERS.set(watcherId, {
-      ...watcherPlaceHolder,
-      path: basePath,
-    });
+  private async doWatch(uri: Uri, options?: { excludes?: string[]; recursive?: boolean }): Promise<number> {
+    const watcherServer = this.getWatcherServer(options?.recursive);
+    if (!watcherServer) {
+      return -1;
+    }
 
     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),
+    });
 
-    const disposables = new DisposableCollection();
-
-    await this.unrecursiveFileSystemWatcher!.watchFileChanges(uri.toString());
+    this.watchedDirs.add(uri.toString());
 
-    disposables.push(
-      Disposable.create(() => {
-        this.unrecursiveFileSystemWatcher!.unwatchFileChanges(uri.toString());
+    const disposable = {
+      dispose: () => {
+        watcherServer.unwatchFileChanges(id);
         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());
+      },
+    };
 
-    return watcherId;
+    this.watcherCollection.set(uri.toString(), { id, options, disposable });
+    return id;
   }
 
-  async $watch(
-    uri: UriComponents,
-    options?: { excludes?: string[]; recursive?: boolean; pollingWatch?: boolean },
-  ): Promise<number> {
+  async $watch(uri: UriComponents, options?: { excludes?: string[]; recursive?: 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, initData.backend);
+  const watcherHostService = new WatcherHostServiceImpl(watcherProtocol, logger);
   watcherHostService.initWatcherServer();
 }
 

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

@@ -7,11 +7,7 @@ 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,
-  RecursiveWatcherBackend,
-} from '@opensumi/ide-core-common/lib/types/file-watch';
+import { DidFilesChangedParams, FileSystemWatcherClient } 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';
@@ -114,7 +110,7 @@ export class WatcherProcessManagerImpl implements IWatcherProcessManager {
     );
   }
 
-  private async createWatcherProcess(clientId: string, ipcHandlerPath: string, backend?: RecursiveWatcherBackend) {
+  private async createWatcherProcess(clientId: string, ipcHandlerPath: string) {
     const forkArgs = [
       `--${SUMI_WATCHER_PROCESS_SOCK_KEY}=${JSON.stringify({
         path: ipcHandlerPath,
@@ -122,7 +118,6 @@ export class WatcherProcessManagerImpl implements IWatcherProcessManager {
       `--${WATCHER_INIT_DATA_KEY}=${JSON.stringify({
         logDir: this.appConfig.logDir,
         logLevel: this.appConfig.logLevel,
-        backend,
         clientId,
       })}`,
     ];
@@ -141,14 +136,14 @@ export class WatcherProcessManagerImpl implements IWatcherProcessManager {
     return this.watcherProcess.pid;
   }
 
-  async createProcess(clientId: string, backend?: RecursiveWatcherBackend) {
+  async createProcess(clientId: string) {
     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, backend);
+    const pid = await this.createWatcherProcess(clientId, ipcHandlerPath);
 
     return pid;
   }
@@ -163,10 +158,7 @@ export class WatcherProcessManagerImpl implements IWatcherProcessManager {
     }
   }
 
-  async watch(
-    uri: UriComponents,
-    options?: { excludes?: string[]; recursive?: boolean; pollingWatch: boolean },
-  ): Promise<number> {
+  async watch(uri: UriComponents, options?: { excludes?: string[]; recursive?: boolean }): Promise<number> {
     this.logger.log('Wait for watcher process ready...');
     await this._whenReadyDeferred.promise;
     this.logger.log('start watch: ', uri);