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

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