emit event when watcher gives up

Author: MaxKless

apps/nxls/src/main.ts

@@ -10,6 +10,7 @@ import { getDocumentLinks } from '@nx-console/language-server-capabilities-docum
 import { getHover } from '@nx-console/language-server-capabilities-hover';
 import {
   NxChangeWorkspace,
+  NxWatcherOperationalNotification,
   NxWorkspacePathRequest,
   NxWorkspaceRefreshNotification,
   NxWorkspaceRefreshStartedNotification,
@@ -40,7 +41,10 @@ import {
   killGroup,
   loadRootEnvFiles,
 } from '@nx-console/shared-utils';
-import { NativeWatcher } from '@nx-console/shared-watcher';
+import {
+  DaemonWatcherCallback,
+  NativeWatcher,
+} from '@nx-console/shared-watcher';
 import type { ProjectGraph } from 'nx/src/devkit-exports';
 import type { ConfigurationSourceMaps } from 'nx/src/project-graph/utils/project-configuration-utils';
 import { ClientCapabilities, TextDocument } from 'vscode-json-languageservice';
@@ -72,6 +76,24 @@ let CLIENT_CAPABILITIES: ClientCapabilities | undefined = undefined;
 let unregisterFileWatcher: () => Promise<void> = async () => {
   //noop
 };
+const fileWatcherCallback: DaemonWatcherCallback = async (
+  _,
+  projectGraphAndSourceMaps,
+) => {
+  if (!WORKING_PATH) {
+    return;
+  }
+  await reconfigureAndSendNotificationWithBackoff(
+    WORKING_PATH,
+    projectGraphAndSourceMaps,
+  );
+};
+const fileWatcherOperationalCallback = (isOperational: boolean) => {
+  lspLogger.log(`File watcher is operational: ${isOperational}`);
+  connection.sendNotification(NxWatcherOperationalNotification.method, {
+    isOperational,
+  });
+};
 let reconfigureAttempts = 0;
 
 const connection = createConnection(ProposedFeatures.all);
@@ -107,19 +129,8 @@ connection.onInitialize(async (params) => {
 
     unregisterFileWatcher = await languageServerWatcher(
       WORKING_PATH,
-      async (error, projectGraphAndSourceMaps) => {
-        if (!WORKING_PATH) {
-          return;
-        }
-        if (error) {
-          lspLogger.log(error.toString());
-        } else {
-          await reconfigureAndSendNotificationWithBackoff(
-            WORKING_PATH,
-            projectGraphAndSourceMaps,
-          );
-        }
-      },
+      fileWatcherCallback,
+      fileWatcherOperationalCallback,
     );
   } catch (e) {
     lspLogger.log('Unable to get Nx info: ' + e.toString());
@@ -417,9 +428,11 @@ async function reconfigure(
 
   unregisterFileWatcher?.();
 
-  unregisterFileWatcher = await languageServerWatcher(workingPath, async () => {
-    reconfigureAndSendNotificationWithBackoff(workingPath);
-  });
+  unregisterFileWatcher = await languageServerWatcher(
+    workingPath,
+    fileWatcherCallback,
+    fileWatcherOperationalCallback,
+  );
 
   return workspace;
 }

libs/language-server/types/src/index.ts

@@ -34,6 +34,10 @@ export const NxWorkspaceRefreshNotification: NotificationType<void> =
 export const NxWorkspaceRefreshStartedNotification: NotificationType<void> =
   new NotificationType('nx/refreshWorkspaceStarted');
 
+export const NxWatcherOperationalNotification: NotificationType<{
+  isOperational: boolean;
+}> = new NotificationType('nx/fileWatcherOperational');
+
 export const NxStopDaemonRequest: RequestType<undefined, undefined, unknown> =
   new RequestType('nx/stopDaemon');
 

libs/language-server/watcher/src/lib/watcher.ts

@@ -58,27 +58,36 @@ export async function cleanupAllWatchers(): Promise<void> {
 export async function languageServerWatcher(
   workspacePath: string,
   callback: DaemonWatcherCallback,
+  watcherOperationalCallback?: (isOperational: boolean) => void,
 ): Promise<() => Promise<void>> {
   const nxVersion = await getNxVersion(workspacePath);
   if (!nxVersion || !gte(nxVersion, '16.4.0')) {
     lspLogger.log(
       'File watching is not supported for Nx versions below 16.4.0.',
     );
+    watcherOperationalCallback?.(false);
     return async () => {
       lspLogger.log('unregistering empty watcher');
     };
   }
 
   if (gte(nxVersion, '22.0.0')) {
-    return registerPassiveDaemonWatcher(workspacePath, callback);
+    return registerPassiveDaemonWatcher(
+      workspacePath,
+      callback,
+      watcherOperationalCallback,
+    );
   } else {
+    // older versions don't have this granular watcher tracking so we just assume true
+    watcherOperationalCallback?.(true);
     return registerOldWatcher(workspacePath, nxVersion, callback);
   }
 }
 
 async function registerPassiveDaemonWatcher(
   workspacePath: string,
   callback: DaemonWatcherCallback,
+  watcherOperationalCallback?: (isOperational: boolean) => void,
 ): Promise<() => Promise<void>> {
   const daemonClient = await getNxDaemonClient(workspacePath, lspLogger);
 
@@ -89,7 +98,11 @@ async function registerPassiveDaemonWatcher(
     };
   }
   try {
-    _passiveDaemonWatcher = new PassiveDaemonWatcher(workspacePath, lspLogger);
+    _passiveDaemonWatcher = new PassiveDaemonWatcher(
+      workspacePath,
+      lspLogger,
+      watcherOperationalCallback,
+    );
     await _passiveDaemonWatcher.start();
     _passiveDaemonWatcher.listen((error, projectGraphAndSourceMaps) => {
       callback(error, projectGraphAndSourceMaps);

libs/shared/nx-workspace-info/src/lib/workspace.ts

@@ -95,15 +95,8 @@ async function _workspace(
 
     const isLerna = await fileExists(join(workspacePath, 'lerna.json'));
 
-    const isAvailable =
-      await daemonClientModule?.daemonClient.isServerAvailable();
-    const isRunning = execSync(`npx nx daemon`);
-
-    logger.log(`isAvailable: ${isAvailable}, isRunning: ${isRunning}`);
     return {
       daemonEnabled: daemonClientModule?.isDaemonEnabled() ?? false,
-      daemonRunning:
-        (await daemonClientModule?.daemonClient.isServerAvailable()) ?? false,
       projectGraph: projectGraph ?? {
         nodes: {},
         dependencies: {},
@@ -129,7 +122,6 @@ async function _workspace(
     // Default to nx workspace
     return {
       daemonEnabled: false,
-      daemonRunning: false,
       validWorkspaceJson: false,
       projectGraph: {
         nodes: {},

libs/shared/types/src/lib/nx-workspace.ts

@@ -13,7 +13,6 @@ export type NxProjectConfiguration = ProjectConfiguration & {
 
 export interface NxWorkspace {
   daemonEnabled: boolean;
-  daemonRunning: boolean;
   validWorkspaceJson: boolean;
   nxJson: NxJsonConfiguration;
   projectGraph: ProjectGraph;

libs/shared/watcher/src/lib/passive-daemon-watcher.spec.ts

@@ -290,7 +290,7 @@ describe('PassiveDaemonWatcher', () => {
 
   describe('Exponential Backoff', () => {
     it(
-      'should use exponential backoff for retries (2s, 5s, 10s, 20s, 40s)',
+      'should use exponential backoff for retries (2s, 5s, 10s, 20s)',
       async () => {
         (getNxDaemonClient as jest.Mock).mockRejectedValue(
           new Error('Always fails'),
@@ -314,16 +314,13 @@ describe('PassiveDaemonWatcher', () => {
         await new Promise((resolve) => setTimeout(resolve, 20500));
         expect(getNxDaemonClient).toHaveBeenCalledTimes(5);
 
-        await new Promise((resolve) => setTimeout(resolve, 40500));
-        expect(getNxDaemonClient).toHaveBeenCalledTimes(6);
-
         watcher.dispose();
       },
-      90000,
+      50000,
     );
 
     it(
-      'should stop retrying after 5 failed attempts',
+      'should stop retrying after 4 failed attempts',
       async () => {
         (getNxDaemonClient as jest.Mock).mockRejectedValue(
           new Error('Always fails'),
@@ -334,17 +331,17 @@ describe('PassiveDaemonWatcher', () => {
 
         await flushPromises();
 
-        await new Promise((resolve) => setTimeout(resolve, 80000));
+        await new Promise((resolve) => setTimeout(resolve, 40000));
 
-        expect(getNxDaemonClient).toHaveBeenCalledTimes(6);
+        expect(getNxDaemonClient).toHaveBeenCalledTimes(5);
 
         await new Promise((resolve) => setTimeout(resolve, 5000));
 
-        expect(getNxDaemonClient).toHaveBeenCalledTimes(6);
+        expect(getNxDaemonClient).toHaveBeenCalledTimes(5);
 
         watcher.dispose();
       },
-      90000,
+      50000,
     );
   });
 
@@ -400,6 +397,114 @@ describe('PassiveDaemonWatcher', () => {
       expect(listener).not.toHaveBeenCalled();
     });
   });
+
+  describe('Operational State Callback', () => {
+    it('should call callback with true when starting', async () => {
+      const onOperationalStateChange = jest.fn();
+      const watcher = new PassiveDaemonWatcher(
+        '/workspace',
+        mockLogger,
+        onOperationalStateChange,
+      );
+
+      watcher.start();
+      await flushPromises();
+
+      expect(onOperationalStateChange).toHaveBeenCalledWith(true);
+
+      watcher.dispose();
+    });
+
+    it('should call callback with true when listening', async () => {
+      const onOperationalStateChange = jest.fn();
+      const watcher = new PassiveDaemonWatcher(
+        '/workspace',
+        mockLogger,
+        onOperationalStateChange,
+      );
+
+      watcher.start();
+      await flushPromises();
+
+      expect(onOperationalStateChange).toHaveBeenCalledWith(true);
+
+      watcher.dispose();
+    });
+
+    it('should call callback with true when failed but can retry', async () => {
+      const onOperationalStateChange = jest.fn();
+      (getNxDaemonClient as jest.Mock).mockRejectedValueOnce(
+        new Error('Failed once'),
+      );
+
+      const watcher = new PassiveDaemonWatcher(
+        '/workspace',
+        mockLogger,
+        onOperationalStateChange,
+      );
+
+      watcher.start();
+      await flushPromises();
+
+      const trueCalls = onOperationalStateChange.mock.calls.filter(
+        (call) => call[0] === true,
+      );
+      expect(trueCalls.length).toBeGreaterThan(0);
+
+      watcher.dispose();
+    });
+
+    it(
+      'should call callback with false when permanently failed',
+      async () => {
+        const onOperationalStateChange = jest.fn();
+        (getNxDaemonClient as jest.Mock).mockRejectedValue(
+          new Error('Always fails'),
+        );
+
+        const watcher = new PassiveDaemonWatcher(
+          '/workspace',
+          mockLogger,
+          onOperationalStateChange,
+        );
+
+        watcher.start();
+        await flushPromises();
+
+        await new Promise((resolve) => setTimeout(resolve, 45000));
+        await flushPromises();
+
+        const falseCalls = onOperationalStateChange.mock.calls.filter(
+          (call) => call[0] === false,
+        );
+        expect(falseCalls.length).toBeGreaterThan(0);
+
+        watcher.dispose();
+      },
+      50000,
+    );
+
+    it('should call callback with true after stop', async () => {
+      const onOperationalStateChange = jest.fn();
+      const watcher = new PassiveDaemonWatcher(
+        '/workspace',
+        mockLogger,
+        onOperationalStateChange,
+      );
+
+      watcher.start();
+      await flushPromises();
+
+      onOperationalStateChange.mockClear();
+
+      watcher.stop();
+      await flushPromises();
+
+      expect(onOperationalStateChange).toHaveBeenCalledWith(true);
+
+      watcher.dispose();
+    });
+  });
 });
 
 async function flushPromises() {