Diagnostics: connectivity: add settings for check interval

This adds a setting to adjust how often to do the network connectivity
check, in milliseconds, where setting it to zero disables the check.  Also
update the check itself to use lower-level APIs to avoid the issue with
Electron not handling redirects correctly (which seems to actually cause
the check to always pass).

Signed-off-by: Mark Yen <[email protected]>

Author: mook-as

pkg/rancher-desktop/assets/specs/command-api.yaml

@@ -792,6 +792,17 @@ components:
               # TODO It is not possible to modify this setting via `rdctl set`.
               x-rd-usage: diagnostic ids that have been muted
               additionalProperties: true
+            connectivity:
+              type: object
+              properties:
+                interval:
+                  type: integer
+                  x-rd-usage: >-
+                    Number of milliseconds before polling for network access;
+                    set this to zero to disable background connectivity checking.
+                timeout:
+                  type: integer
+                  x-rd-usage: Number of milliseconds to wait before timing out
 
     diagnostics:
       type: object

pkg/rancher-desktop/config/settings.ts

@@ -118,8 +118,12 @@ export const defaultSettings = {
     namespace: 'default',
   },
   diagnostics: {
-    showMuted:   false,
-    mutedChecks: {} as Record<string, boolean>,
+    showMuted:    false,
+    mutedChecks:  {} as Record<string, boolean>,
+    connectivity: {
+      interval: 5_000,
+      timeout:  5_000,
+    },
   },
   /**
    * Experimental settings

pkg/rancher-desktop/main/commandServer/settingsValidator.ts

@@ -158,8 +158,12 @@ export default class SettingsValidator {
         namespace: this.checkString,
       },
       diagnostics: {
-        mutedChecks: this.checkBooleanMapping,
-        showMuted:   this.checkBoolean,
+        mutedChecks:  this.checkBooleanMapping,
+        showMuted:    this.checkBoolean,
+        connectivity: {
+          interval: this.checkNumber(0, 2 ** 31 - 1),
+          timeout:  this.checkNumber(1, 2 ** 31 - 1),
+        },
       },
     };
     this.canonicalizeSynonyms(newSettings);

pkg/rancher-desktop/main/diagnostics/connectedToInternet.ts

@@ -2,62 +2,56 @@ import { net } from 'electron';
 
 import { DiagnosticsCategory, DiagnosticsChecker } from './types';
 
+import mainEvents from '@pkg/main/mainEvents';
 import Logging from '@pkg/utils/logging';
 
 const console = Logging.diagnostics;
 
-// Returns the timeout, in milliseconds, for the network connectivity check.
-function getTimeout(): number {
-  if (process.env.RD_CONNECTED_TO_INTERNET_TIMEOUT) {
-    const parsedTimeout = parseInt(process.env.RD_CONNECTED_TO_INTERNET_TIMEOUT);
+let pollingInterval: NodeJS.Timeout;
+let timeout = 5_000;
 
-    if (parsedTimeout > 0) {
-      return parsedTimeout;
-    }
-  }
+// Since this is just a status check, it's fine to just reset the timer every
+// time _any_ setting has been updated.
+mainEvents.on('settings-update', settings => {
+  clearInterval(pollingInterval);
 
-  return 5000;
-}
+  const { timeout: localTimeout, interval } = settings.diagnostics.connectivity;
+
+  timeout = localTimeout;
+  if (interval > 0) {
+    pollingInterval = setInterval(() => {
+      mainEvents.invoke('diagnostics-trigger', CheckConnectedToInternet.id);
+    }, interval);
+  }
+});
 
 /**
  * Checks whether we can perform an HTTP request to a host on the internet,
  * with a reasonably short timeout.
  */
 async function checkNetworkConnectivity(): Promise<boolean> {
-  const controller = new AbortController();
-  const timeout = getTimeout();
-  const timeoutId = setTimeout(() => controller.abort(), timeout);
-  let connected: boolean;
-
-  try {
+  const request = net.request({
     // Using HTTP request that returns a 301 redirect response instead of a 20+ kB web page
-    const resp = await net.fetch('http://docs.rancherdesktop.io/', { signal: controller.signal, redirect: 'manual' });
-    const location = resp.headers.get('Location') || '';
-
-    // Verify that we get the original redirect and not a captive portal
-    if (resp.status !== 301 || !location.includes('docs.rancherdesktop.io')) {
-      throw new Error(`expected status 301 (was ${ resp.status }) and location including docs.rancherdesktop.io (was ${ location })`);
-    }
-    connected = true;
-  } catch (error: any) {
-    let errorMessage = error;
-
-    if (/Redirect was cancelled/.test(error)) {
-      // Electron does not currently handle manual redirects correctly.
-      // https://github.com/electron/electron/issues/43715
-      connected = true;
-    } else {
-      if (error.name === 'AbortError') {
-        errorMessage = `timed out after ${ timeout } ms`;
-      }
-      console.log(`Got error while checking connectivity: ${ errorMessage }`);
-      connected = false;
-    }
+    url:         'http://docs.rancherdesktop.io/',
+    credentials: 'omit',
+    redirect:    'manual',
+    cache:       'no-cache',
+  });
+  const timeoutId = setTimeout(() => {
+    console.log(`${ CheckConnectedToInternet.id }: aborting due to timeout after ${ timeout } milliseconds.`);
+    request.abort();
+  }, timeout);
+  try {
+    return await new Promise<boolean>(resolve => {
+      request.on('response', () => resolve(true));
+      request.on('redirect', () => resolve(true));
+      request.on('error', () => resolve(false));
+      request.on('abort', () => resolve(false));
+      request.end();
+    });
   } finally {
     clearTimeout(timeoutId);
   }
-
-  return connected;
 }
 
 /**
@@ -71,7 +65,9 @@ const CheckConnectedToInternet: DiagnosticsChecker = {
     return Promise.resolve(true);
   },
   async check() {
-    if (await checkNetworkConnectivity()) {
+    const connected = await checkNetworkConnectivity();
+    mainEvents.emit('diagnostics-event', { id: 'network-connectivity', connected });
+    if (connected) {
       return {
         description: 'The application can reach the internet successfully.',
         passed:      true,

pkg/rancher-desktop/main/mainEvents.ts

@@ -174,6 +174,7 @@ interface MainEventNames {
 type DiagnosticsEventPayload =
   { id: 'integrations-windows', distro?: string, key: string, error?: Error } |
   { id: 'kube-versions-available', available: boolean } |
+  { id: 'network-connectivity', connected: boolean } |
   { id: 'path-management', fileName: string; error: Error | undefined };
 
 /**

pkg/rancher-desktop/main/tray.ts

@@ -36,7 +36,6 @@ export class Tray {
   private currentNetworkStatus:    networkStatus = networkStatus.CHECKING;
   private static instance:         Tray;
   private networkState:            boolean | undefined;
-  private networkInterval:         NodeJS.Timeout;
   private runBuildFromConfigTimer: NodeJS.Timeout | null = null;
   private kubeConfigWatchers:      fs.FSWatcher[] = [];
   private fsWatcherInterval:       NodeJS.Timeout;
@@ -199,25 +198,24 @@ export class Tray {
     mainEvents.on('k8s-check-state', this.k8sStateChangedEvent);
     mainEvents.on('settings-update', this.settingsUpdateEvent);
 
-    // This triggers the CONNECTED_TO_INTERNET diagnostic at a set interval and
-    // updates the network status in the tray if there's a change in the network
-    // state.
-    this.networkInterval = setInterval(async() => {
-      let networkDiagnostic = await mainEvents.invoke('diagnostics-trigger', 'CONNECTED_TO_INTERNET');
-
-      if (Array.isArray(networkDiagnostic)) {
-        networkDiagnostic = networkDiagnostic.shift();
+    // If the network connectivity diagnostic changes results, update it here.
+    mainEvents.on('diagnostics-event', payload => {
+      if (payload.id !== 'network-connectivity') {
+        return;
       }
-      if (this.networkState === networkDiagnostic?.passed) {
+
+      const { connected } = payload;
+
+      if (this.networkState === connected) {
         return; // network state hasn't changed since last check
       }
 
-      this.networkState = !!networkDiagnostic?.passed;
+      this.networkState = connected;
 
       this.handleUpdateNetworkStatus(this.networkState).catch((err: any) => {
         console.log('Error updating network status: ', err);
       });
-    }, 5000);
+    });
   }
 
   private backendStateEvent = (backendIsLocked: string) => {
@@ -258,7 +256,6 @@ export class Tray {
     mainEvents.off('settings-update', this.settingsUpdateEvent);
     ipcMainProxy.removeListener('update-network-status', this.updateNetworkStatusEvent);
     clearInterval(this.fsWatcherInterval);
-    clearInterval(this.networkInterval);
     if (this.runBuildFromConfigTimer) {
       clearTimeout(this.runBuildFromConfigTimer);
       this.runBuildFromConfigTimer = null;