@opensumi/ide-file-service 3.7.1-next-1739439717.0 → 3.7.1-next-1739521933.0

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,19 @@ 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.watcherCollection.delete(_uri);
+        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 +99,84 @@ 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(async () => {
+        this.unrecursiveFileSystemWatcher!.unwatchFileChanges(uri.toString());
+        this.logger.log('dispose unrecursive watcher: ', uri.toString());
         this.watchedDirs.delete(uri.toString());
-      },
-    };
+        this.WATCHER_HANDLERS.delete(watcherId);
+      }),
+    );
+
+    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(async () => {
+            this.logger.log('dispose recursive watcher: ', uri.toString());
+            this.recursiveFileSystemWatcher!.unwatchFileChanges(uri.toString());
+            this.watchedDirs.delete(uri.toString());
+            this.WATCHER_HANDLERS.delete(watcherId);
+          }),
+        );
+      } 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);