Steve: address AI review comments

Signed-off-by: Mark Yen <mark.yen@suse.com>

Author: mook-as

pkg/rancher-desktop/backend/steve.ts

@@ -184,6 +184,15 @@ export class Steve {
 
       req.on('response', (res) => resolve(res.statusCode === 200));
       req.on('error', () => resolve(false));
+      // Timeout if we don't get a response in a reasonable time.
+      setTimeout(1_000).then(() => {
+        try {
+          req.abort();
+        } catch {
+          // ignore
+        }
+        resolve(false);
+      });
       req.end();
     });
   }

pkg/rancher-desktop/main/dashboardServer/index.ts

@@ -27,7 +27,7 @@ export class DashboardServer {
   private host = '127.0.0.1';
   private port = 6120;
   private stevePort = 0;
-  private proxies:      Record<string, ReturnType<typeof createProxyMiddleware>> = Object.create(null);
+  private proxies:      Record<ProxyKeys, ReturnType<typeof createProxyMiddleware>> = Object.create(null);
 
   /**
    * Checks for an existing instance of Dashboard server.
@@ -95,15 +95,13 @@ export class DashboardServer {
 
     // Register wrapper functions so that when createProxies() replaces
     // this.proxies (on each Steve restart), express and the upgrade
-    // handler automatically use the new instances.  The optional
-    // chaining is safe: proxies are always created before the UI is
-    // notified that Kubernetes is ready, and the dashboard button is
-    // disabled until then.
-    //
-    // ?? next() fires only when the proxy is absent: createProxyMiddleware
-    // returns an async function, so the call always yields a Promise (truthy).
+    // handler automatically use the new instances.  The call is safe: proxies
+    // are always created before the UI is notified that Kubernetes is ready,
+    // and the dashboard button is disabled until then.
     ProxyKeys.forEach((key) => {
-      this.dashboardServer.use(key, (req, res, next) => this.proxies[key]?.(req, res, next) ?? next());
+      this.dashboardServer.use(key, (req, res, next) => {
+        return this.proxies[key] ? this.proxies[key](req, res, next) : next();
+      });
     });
 
     this.dashboardApp = this.dashboardServer
@@ -133,20 +131,15 @@ export class DashboardServer {
           return;
         }
 
-        // TODO: drive this from ProxyKeys instead of maintaining a parallel list.
-        const key = req.url?.startsWith('/v1')
-          ? '/v1'
-          : req.url?.startsWith('/v3')
-            ? '/v3'
-            : req.url?.startsWith('/k8s/')
-              ? '/k8s'
-              : req.url?.startsWith('/api/')
-                ? '/api'
-                : undefined;
-
-        if (key) {
-          return this.proxies[key]?.upgrade(req, socket, head);
+        const upgradeKeys = new Set<ProxyKeys>(['/v1', '/v3', '/k8s', '/api']);
+        const key = Array.from(upgradeKeys).find((key) => {
+          return req.url === key || req.url?.startsWith(key + '/');
+        });
+
+        if (key && this.proxies[key]) {
+          return this.proxies[key].upgrade(req, socket, head);
         }
+
         console.log(`Unknown Web socket upgrade request for ${ req.url }`);
         socket.destroy();
       });

pkg/rancher-desktop/utils/__tests__/networks.spec.ts

@@ -40,4 +40,11 @@ describe('getAvailablePorts', () => {
 
     expect(ports[0]).not.toBe(ports[1]);
   });
+
+  it('can accept dynamic counts', async() => {
+    const count = Math.floor(1.0); // Force number type, not a literal.
+    const ports = await getAvailablePorts(count);
+
+    expect(ports).toHaveLength(count);
+  });
 });

pkg/rancher-desktop/utils/networks.ts

@@ -7,14 +7,21 @@ export enum networkStatus {
   OFFLINE = 'offline',
 }
 
+/**
+ * TupleOf<T, N> is a tuple of N elements of type T.
+ */
+type TupleOf<T, N extends number, R extends T[] = []> =
+  number extends N ? T[] : // If N is not a literal, return a normal array.
+    R['length'] extends N ? R : TupleOf<T, N, [...R, T]>;
+
 /**
  * Ask the OS to assign free ports on localhost. All ports are bound
  * simultaneously before any are released, guaranteeing distinct values.
  * The ports are released before returning, so there is a small TOCTOU
  * race before the caller binds them. In practice the risk is negligible
  * because the caller (Steve) binds within seconds.
  */
-export async function getAvailablePorts(count: number): Promise<number[]> {
+export async function getAvailablePorts<N extends number>(count: N): Promise<TupleOf<number, N>> {
   const servers: net.Server[] = [];
 
   try {
@@ -28,7 +35,7 @@ export async function getAvailablePorts(count: number): Promise<number[]> {
       });
     }
 
-    return servers.map(s => (s.address() as net.AddressInfo).port);
+    return servers.map(s => (s.address() as net.AddressInfo).port) as TupleOf<number, N>;
   } finally {
     await Promise.all(servers.map(s =>
       new Promise<void>(resolve => s.close(() => resolve()))));