Merge branch 'main' of https://github.com/opendatahub-io/odh-dashboard into feat/autorag

Author: Daniel Duong

AGENTS.md

@@ -83,5 +83,6 @@ Before performing certain tasks, read and follow the corresponding specialized r
 | **Contract Tests**    | [docs/agent-rules/contract-tests.md](docs/agent-rules/contract-tests.md)     | When working on contract tests or BFF API validation                         |
 | **Cypress E2E Tests** | [docs/agent-rules/cypress-e2e.md](docs/agent-rules/cypress-e2e.md)           | When creating or modifying E2E tests, Robot Framework migrations             |
 | **Cypress Mock Tests**| [docs/agent-rules/cypress-mock.md](docs/agent-rules/cypress-mock.md)         | When creating or modifying mock/component tests                              |
+| **Unit Tests**        | [docs/agent-rules/unit-tests.md](docs/agent-rules/unit-tests.md)             | When creating or modifying Jest unit tests for utilities, hooks, or components |
 
 **Important**: Always read the relevant rule file before starting the task to ensure you follow the project's conventions and patterns.

OWNERS

@@ -16,6 +16,7 @@ filters:
       - workbenches-approvers
       - gen-ai-approvers
       - nim-serving-approvers
+      - autorag-approvers
 
   # Catchall
   '.*':
@@ -147,3 +148,12 @@ filters:
       - notebooks-reviewers
     labels:
       - 'area/notebooks'
+
+  # AutoRAG
+  'packages/autorag/.*':
+    approvers:
+      - autorag-approvers
+    reviewers:
+      - autorag-reviewers
+    labels:
+      - 'area/autorag'

OWNERS_ALIASES

@@ -150,7 +150,7 @@ aliases:
     - rhdedgar
     - iamemilio
     - s-akhtar-baig
-    
+
   # Notebooks
   notebooks-approvers:
     - andyatmiami
@@ -181,3 +181,17 @@ aliases:
     - mtalvi
     - xieshenzh
     - swati-kale
+
+  # AutoRAG
+  autorag-approvers:
+    - nickmazzi
+    - chrjones-rh
+  autorag-reviewers:
+    - nickmazzi
+    - chrjones-rh
+    - srtanish1992
+    - daniduong
+    - GAUNSD
+    - jefho-rh
+    - MatthewAThompson
+    - jkyaw

backend/src/__tests__/websocket-proxy.spec.ts

@@ -586,6 +586,36 @@ describe('WebSocket K8s Proxy', () => {
         expect.stringContaining('Unexpected response from K8s API'),
       );
     });
+
+    it('should convert reserved close code 1006 to 1011 when forwarding to client', async () => {
+      // Code 1006 (Abnormal Closure) cannot be sent in a close frame per RFC 6455
+      // The ws module enforces this. We convert it to 1011 (Internal Error).
+      await routeHandler(mockConnection, mockRequest);
+
+      const targetCloseHandler = mockTargetSocket.on.mock.calls.find(
+        (call: any) => call[0] === 'close',
+      )?.[1];
+
+      // K8s API closes with code 1006 (abnormal closure - e.g., network drop)
+      targetCloseHandler(1006, 'Abnormal closure');
+
+      // Client socket should receive 1011 instead of 1006
+      expect(mockSourceSocket.close).toHaveBeenCalledWith(1011, 'Abnormal closure');
+    });
+
+    it('should pass through normal close codes unchanged', async () => {
+      await routeHandler(mockConnection, mockRequest);
+
+      const targetCloseHandler = mockTargetSocket.on.mock.calls.find(
+        (call: any) => call[0] === 'close',
+      )?.[1];
+
+      // K8s API closes with normal code 1000
+      targetCloseHandler(1000, 'Normal closure');
+
+      // Client socket should receive 1000 unchanged
+      expect(mockSourceSocket.close).toHaveBeenCalledWith(1000, 'Normal closure');
+    });
   });
 
   describe('Stale Connection Cleanup', () => {
@@ -602,7 +632,7 @@ describe('WebSocket K8s Proxy', () => {
       // Connection is still active, so no cleanup warning yet
       expect(mockLog.warn).not.toHaveBeenCalledWith(
         expect.anything(),
-        expect.stringContaining('Removing stale connection'),
+        expect.stringContaining('Closing stale websocket connection'),
       );
 
       // Advance time beyond stale threshold
@@ -614,9 +644,78 @@ describe('WebSocket K8s Proxy', () => {
         expect.objectContaining({
           inactivityDuration: expect.any(Number),
         }),
-        expect.stringContaining('Removing stale connection from tracking'),
+        expect.stringContaining('Closing stale websocket connection'),
+      );
+    });
+
+    /**
+     * This test verifies the fix for the zombie connection bug:
+     *
+     * When a connection becomes stale, both websockets are now properly closed
+     * so that the client receives the close event and can reconnect.
+     */
+    it('should close websockets when cleaning up stale connections', async () => {
+      await wssK8sRoutes(mockFastify);
+      routeHandler = (mockFastify.get as jest.Mock).mock.calls[0][2];
+
+      // Create a connection
+      await routeHandler(mockConnection, mockRequest);
+
+      // Verify sockets haven't been closed yet
+      expect(mockSourceSocket.close).not.toHaveBeenCalled();
+      expect(mockTargetSocket.close).not.toHaveBeenCalled();
+
+      // Let connection become stale (advance past threshold + cleanup cycle)
+      jest.advanceTimersByTime(STALE_CONNECTION_MS + 60000);
+
+      // Verify stale cleanup ran
+      expect(mockLog.warn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          inactivityDuration: expect.any(Number),
+        }),
+        expect.stringContaining('Closing stale websocket connection'),
+      );
+
+      // Both websockets should be closed with code 1001 (Going Away)
+      expect(mockSourceSocket.close).toHaveBeenCalledWith(
+        1001,
+        'Connection stale due to inactivity',
+      );
+      expect(mockTargetSocket.close).toHaveBeenCalledWith(
+        1001,
+        'Connection stale due to inactivity',
       );
     });
+
+    /**
+     * This test verifies that heartbeat intervals are properly cleared
+     * when cleaning up stale connections.
+     */
+    it('should clear heartbeat interval when cleaning up stale connections', async () => {
+      await wssK8sRoutes(mockFastify);
+      routeHandler = (mockFastify.get as jest.Mock).mock.calls[0][2];
+
+      // Create a connection
+      await routeHandler(mockConnection, mockRequest);
+
+      // Simulate connection opening to start heartbeat
+      const openHandler = mockTargetSocket.on.mock.calls.find(
+        (call: any) => call[0] === 'open',
+      )?.[1];
+      openHandler();
+
+      // Verify heartbeat is running
+      jest.advanceTimersByTime(HEARTBEAT_INTERVAL_MS);
+      expect(mockTargetSocket.ping).toHaveBeenCalledTimes(1);
+
+      // Advance time beyond stale threshold + cleanup cycle
+      jest.advanceTimersByTime(STALE_CONNECTION_MS + 60000);
+
+      // After cleanup, heartbeat should be stopped - no more pings
+      const pingCountAfterCleanup = mockTargetSocket.ping.mock.calls.length;
+      jest.advanceTimersByTime(HEARTBEAT_INTERVAL_MS * 3);
+      expect(mockTargetSocket.ping.mock.calls.length).toBe(pingCountAfterCleanup);
+    });
   });
 
   describe('Configuration Constants', () => {

backend/src/routes/wss/k8s/index.ts

@@ -10,10 +10,23 @@ const base64 = (data: string): string =>
   // eslint-disable-next-line no-restricted-properties
   Buffer.from(data).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').split('=', 1)[0];
 
+/**
+ * Convert reserved WebSocket close codes to valid codes that can be sent in a close frame.
+ *
+ * Per RFC 6455, certain codes cannot be set by applications:
+ * - 1004: Reserved
+ * - 1005: No Status Received (MUST NOT be set in close frame)
+ * - 1006: Abnormal Closure (MUST NOT be set in close frame, indicates no close frame received)
+ *
+ * The `ws` module enforces this and throws if you try to close with these codes.
+ *
+ * We convert these to 1011 (Internal Error) which is semantically appropriate:
+ * "The server is terminating the connection because it encountered an unexpected condition"
+ */
 const liftErrorCode = (code: number) => {
   if (code === 1004 || code === 1005 || code === 1006) {
-    // ws module forbid those error codes usage, lift to "application level" (4xxx)
-    return 3000 + code;
+    // Use 1011 (Internal Error) as a valid substitute for reserved codes
+    return 1011;
   }
   return code;
 };
@@ -43,8 +56,17 @@ type ConnectionMetrics = {
   lastResourceVersion?: string;
 };
 
+// Connection tracking includes metrics plus socket references for proper cleanup
+type TrackedConnection = {
+  metrics: ConnectionMetrics;
+  source: WebSocket;
+  target: WebSocket;
+  kubeUri: string;
+  heartbeatInterval: NodeJS.Timeout | null;
+};
+
 // Global connection tracking for monitoring and cleanup
-const activeConnections = new Map<string, ConnectionMetrics>();
+const activeConnections = new Map<string, TrackedConnection>();
 
 // Constants for connection management (exported for testing)
 export const CONNECTION_TIMEOUT_MS = 10000; // 10 seconds to establish connection
@@ -56,7 +78,8 @@ const cleanupStaleConnections = (fastify: KubeFastifyInstance) => {
   const now = Date.now();
   let cleanedCount = 0;
 
-  for (const [connectionId, metrics] of activeConnections.entries()) {
+  for (const [connectionId, tracked] of activeConnections.entries()) {
+    const { metrics, source, target, kubeUri, heartbeatInterval } = tracked;
     const inactivityDuration = now - Math.max(metrics.lastMessageReceived, metrics.lastMessageSent);
 
     if (inactivityDuration > STALE_CONNECTION_MS) {
@@ -66,9 +89,21 @@ const cleanupStaleConnections = (fastify: KubeFastifyInstance) => {
           inactivityDuration,
           messagesReceived: metrics.messagesReceived,
           messagesSent: metrics.messagesSent,
+          duration: now - metrics.created,
         },
-        `Removing stale connection from tracking: ${connectionId}`,
+        `Closing stale websocket connection: ${kubeUri}`,
       );
+
+      // Clear heartbeat interval if it exists
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+      }
+
+      // Close both websockets so the client receives the close event and can reconnect
+      // Use code 1001 (going away) to indicate the server is closing due to inactivity
+      closeWebSocket(source, 1001, 'Connection stale due to inactivity');
+      closeWebSocket(target, 1001, 'Connection stale due to inactivity');
+
       activeConnections.delete(connectionId);
       cleanedCount++;
     }
@@ -121,7 +156,6 @@ export default async (fastify: KubeFastifyInstance): Promise<void> => {
           messagesReceived: 0,
           messagesSent: 0,
         };
-        activeConnections.set(connectionId, metrics);
 
         fastify.log.info(
           {
@@ -147,6 +181,16 @@ export default async (fastify: KubeFastifyInstance): Promise<void> => {
           ca: https.globalAgent.options.ca as WebSocket.CertMeta,
         });
 
+        // Track connection with socket references for proper cleanup
+        const tracked: TrackedConnection = {
+          metrics,
+          source,
+          target,
+          kubeUri,
+          heartbeatInterval: null,
+        };
+        activeConnections.set(connectionId, tracked);
+
         // Close both connections and log diagnostics
         const close = (code: number, reason: string | Buffer) => {
           // Make idempotent - only run once per connection
@@ -169,6 +213,12 @@ export default async (fastify: KubeFastifyInstance): Promise<void> => {
             `Closing websocket connection: ${kubeUri}`,
           );
 
+          // Clear heartbeat interval if it exists
+          if (tracked.heartbeatInterval) {
+            clearInterval(tracked.heartbeatInterval);
+            tracked.heartbeatInterval = null;
+          }
+
           closeWebSocket(source, code, reason);
           closeWebSocket(target, code, reason);
           activeConnections.delete(connectionId);
@@ -189,9 +239,6 @@ export default async (fastify: KubeFastifyInstance): Promise<void> => {
           }
         }, CONNECTION_TIMEOUT_MS);
 
-        // Heartbeat monitoring
-        let heartbeatInterval: NodeJS.Timeout | null = null;
-
         const onUnexpectedResponse = (_: ClientRequest, response: IncomingMessage) => {
           const statusCode = response.statusCode || 'unknown';
           const statusMessage = response.statusMessage || 'unknown';
@@ -219,7 +266,7 @@ export default async (fastify: KubeFastifyInstance): Promise<void> => {
           );
 
           // Start heartbeat monitoring
-          heartbeatInterval = setInterval(() => {
+          tracked.heartbeatInterval = setInterval(() => {
             // Send ping to keep connection alive
             if (target.readyState === WebSocket.OPEN) {
               try {
@@ -311,8 +358,9 @@ export default async (fastify: KubeFastifyInstance): Promise<void> => {
 
         // Handle K8s API connection close
         target.on('close', (code, reason) => {
-          if (heartbeatInterval) {
-            clearInterval(heartbeatInterval);
+          if (tracked.heartbeatInterval) {
+            clearInterval(tracked.heartbeatInterval);
+            tracked.heartbeatInterval = null;
           }
 
           const reasonStr = String(reason);
@@ -378,8 +426,9 @@ export default async (fastify: KubeFastifyInstance): Promise<void> => {
 
         // Handle client connection close
         source.on('close', (code, reason) => {
-          if (heartbeatInterval) {
-            clearInterval(heartbeatInterval);
+          if (tracked.heartbeatInterval) {
+            clearInterval(tracked.heartbeatInterval);
+            tracked.heartbeatInterval = null;
           }
           clearTimeout(connectionTimeout);
 

backend/src/types.ts

@@ -51,6 +51,7 @@ export type DashboardConfig = K8sResourceCommon & {
       disableFeatureStore: boolean;
       trainingJobs: boolean;
       genAiStudio: boolean;
+      autoRag: boolean;
       modelAsService: boolean;
       mlflow: boolean;
       disableLLMd: boolean;

backend/src/utils/constants.ts

@@ -81,6 +81,7 @@ export const blankDashboardCR: DashboardConfig = {
       disableAdminConnectionTypes: false,
       disableFeatureStore: false,
       genAiStudio: false,
+      autoRag: false,
       modelAsService: false,
       maasApiKeys: false,
       disableFineTuning: true,
@@ -89,7 +90,7 @@ export const blankDashboardCR: DashboardConfig = {
       mlflow: false,
       trainingJobs: true,
       disableLLMd: false,
-      projectRBAC: false,
+      projectRBAC: true,
       autorag: false,
     },
     notebookController: {