dashboard-shell-shell 3.0.2-test.20250913 → 3.0.5-test.2

package/utils/__tests__/string.test.ts

@@ -1,4 +1,4 @@
-import { decodeHtml, resourceNames } from '@shell/utils/string';
+import { decodeHtml, resourceNames, pathArrayToTree } from '@shell/utils/string';
 
 describe('fx: decodeHtml', () => {
   it('should decode HTML values from escaped string into valid markup', () => {
@@ -89,3 +89,275 @@ describe('fx: resourceNames', () => {
     });
   });
 });
+
+describe('fx: pathArrayToTree', () => {
+  interface TreeNode {
+    name: string;
+    children: TreeNode[];
+  }
+
+  function sortTree(nodes: TreeNode[]): void {
+    if (!nodes) return;
+    nodes.sort((a, b) => a.name.localeCompare(b.name));
+    nodes.forEach((node) => {
+      if (node.children && node.children.length > 0) {
+        sortTree(node.children);
+      }
+    });
+  }
+
+  it('should return an empty array for an empty input array', () => {
+    const paths: string[] = [];
+
+    expect(pathArrayToTree(paths)).toStrictEqual([]);
+  });
+
+  it('should convert simple single-level paths correctly', () => {
+    const paths: string[] = [
+      'file1.txt',
+      'folderA',
+      'itemB'
+    ];
+    const expected: TreeNode[] = [
+      { name: 'file1.txt', children: [] },
+      { name: 'folderA', children: [] },
+      { name: 'itemB', children: [] },
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual); // Sort the actual output for deterministic comparison
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should convert two-level nested paths correctly', () => {
+    const paths: string[] = [
+      'folderA/file1.txt',
+      'folderC/file3.txt'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     'folderA',
+        children: [
+          { name: 'file1.txt', children: [] },
+        ]
+      },
+      {
+        name:     'folderC',
+        children: [
+          { name: 'file3.txt', children: [] }
+        ]
+      },
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should handle deep nesting and common prefixes correctly', () => {
+    const paths: string[] = [
+      'root/level1/level2/file.doc',
+      'root/level1/another_file.txt',
+      'root/diff_level1/config.json'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     'root',
+        children: [
+          {
+            name:     'diff_level1',
+            children: [
+              { name: 'config.json', children: [] }
+            ]
+          },
+          {
+            name:     'level1',
+            children: [
+              { name: 'another_file.txt', children: [] },
+              {
+                name:     'level2',
+                children: [
+                  { name: 'file.doc', children: [] }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should handle leading/trailing/multiple slashes by treating them as path segments', () => {
+    const paths: string[] = [
+      '/path/to/file.txt', // Starts with a slash
+      'path/to/another.txt/', // Ends with a slash (adds an empty segment)
+      '//root/item//subitem//', // Multiple slashes (adds empty segments)
+      'root/item/another_subitem'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     '',
+        children: [
+          {
+            name:     '',
+            children: [
+              {
+                name:     'root',
+                children: [
+                  {
+                    name:     'item',
+                    children: [
+                      {
+                        name:     '',
+                        children: [
+                          {
+                            name:     'subitem',
+                            children: [
+                              {
+                                name:     '',
+                                children: [
+                                  {
+                                    name:     '',
+                                    children: [
+                                    ],
+                                  },
+                                ],
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            name:     'path',
+            children: [
+              {
+                name:     'to',
+                children: [
+                  {
+                    name:     'file.txt',
+                    children: [
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name:     'path',
+        children: [
+          {
+            name:     'to',
+            children: [
+              {
+                name:     'another.txt',
+                children: [
+                  {
+                    name:     '',
+                    children: [
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name:     'root',
+        children: [
+          {
+            name:     'item',
+            children: [
+              {
+                name:     'another_subitem',
+                children: [
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should produce the same structure regardless of input order', () => {
+    const paths1: string[] = ['a/b', 'a/c'];
+    const paths2: string[] = ['a/c', 'a/b'];
+
+    const actual1 = pathArrayToTree(paths1);
+
+    sortTree(actual1);
+    const actual2 = pathArrayToTree(paths2);
+
+    sortTree(actual2);
+
+    expect(actual1).toStrictEqual(actual2);
+  });
+
+  it('should handle names with special characters (not slashes) correctly', () => {
+    const paths: string[] = [
+      'my-folder/file_name.1.txt',
+      'another folder/item with spaces'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     'another folder',
+        children: [
+          { name: 'item with spaces', children: [] }
+        ]
+      },
+      {
+        name:     'my-folder',
+        children: [
+          { name: 'file_name.1.txt', children: [] }
+        ]
+      }
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should handle duplicate paths correctly, only adding unique structure', () => {
+    const paths: string[] = [
+      'folder/file.txt',
+      'folder/file.txt', // Duplicate
+      'other_folder/another_file.txt'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     'folder',
+        children: [
+          { name: 'file.txt', children: [] }
+        ]
+      },
+      {
+        name:     'other_folder',
+        children: [
+          { name: 'another_file.txt', children: [] }
+        ]
+      }
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+});

package/utils/__tests__/time.test.ts

@@ -0,0 +1,31 @@
+import { DATE_FORMAT, TIME_FORMAT } from '@shell/store/prefs';
+import { dateTimeFormat } from '@shell/utils/time';
+import { type Store } from 'vuex';
+
+describe('function: dateTimeFormat', () => {
+  jest.useFakeTimers()
+    .setSystemTime(new Date('21-10-2010 4:29:00'));
+  const store = {
+    getters: {
+      'prefs/get': (key: string) => {
+        return {
+          [DATE_FORMAT]: 'ddd, MMM D YYYY',
+          [TIME_FORMAT]: 'h:mm:ss a',
+        }[key];
+      },
+    },
+  } as Store<any>;
+
+  it('should format date and time correctly', () => {
+    const date = new Date('2010-10-21T04:29:00Z');
+    const formattedDate = dateTimeFormat(date.toISOString(), store);
+
+    expect(formattedDate).toBe('Thu, Oct 21 2010 4:29:00 am');
+  });
+
+  it('should return empty string for undefined value', () => {
+    const formattedDate = dateTimeFormat(undefined, store);
+
+    expect(formattedDate).toBe('');
+  });
+});

package/utils/auth.js

@@ -8,6 +8,9 @@ import { allHash } from '@shell/utils/promise';
 import { getProductFromRoute, getResourceFromRoute } from '@shell/utils/router';
 import { NAME as EXPLORER } from '@shell/config/product/explorer';
 import { findBy } from '@shell/utils/array';
+import { onExtensionsReady } from '@shell/utils/uiplugins';
+
+export const AUTH_BROADCAST_CHANNEL_NAME = 'rancher-auth-test-callback';
 
 export function openAuthPopup(url, provider) {
   const popup = new Popup(() => {
@@ -16,19 +19,46 @@ export function openAuthPopup(url, provider) {
       popup.reject = reject;
     });
 
+    const bc = new BroadcastChannel(AUTH_BROADCAST_CHANNEL_NAME);
+
     window.onAuthTest = (error, code) => {
       if (error) {
         popup.reject(error);
       }
 
+      bc.close();
       delete window.onAuthTest;
       popup.resolve(code);
     };
-  }, () => {
-    popup.reject(new Error('Access was not authorized'));
+
+    // Broadcast message listener for when the window can not invoke a method on the opener
+    bc.onmessage = (msgEvent) => {
+      try {
+        const obj = JSON.parse(msgEvent.data);
+        const { error, code } = obj;
+
+        window.onAuthTest(error, code);
+      } catch (e) {
+        window.onAuthTest(new Error(`Access was not authorized (invalid callback metadata)`));
+
+        console.error('Unable to process message from auth broadcast channel', e); // eslint-disable-line no-console
+      }
+    };
+  }, (e) => {
+    let detail = '';
+
+    // If there was an error and it has a message, add that to the message we send back via the promise
+    if (e?.type === 'error' && e?.message) {
+      detail = ` (${ e.message })`;
+    }
+
+    popup.reject(new Error(`Access was not authorized${ detail }`));
   });
 
-  popup.open(url, 'auth-test', popupWindowOptions());
+  // So far, only Amazon Cognito sets the origin policy that prevents us from detecting when the popup is closed
+  const doNotPollForClosure = provider === 'cognito';
+
+  popup.open(url, 'auth-test', popupWindowOptions(), doNotPollForClosure);
 
   return popup.promise;
 }
@@ -242,7 +272,6 @@ export function setProduct(store, to) {
  */
 export function validateResource(store, to) {
   const product = store.getters['currentProduct'];
-  
   const resource = getResourceFromRoute(to);
 
   // In order to check a resource is valid we need these
@@ -305,9 +334,15 @@ export async function tryInitialSetup(store, password = 'admin') {
 /**
  * Record in our state management that we're indeed logged in
  */
-export function isLoggedIn(store, me) {
+export async function isLoggedIn(store, userData) {
   store.commit('auth/hasAuth', true);
-  store.commit('auth/loggedInAs', me.id);
+  store.commit('auth/loggedInAs', userData.id);
+
+  // Init the notification center now that we know who the user is
+  await store.dispatch('notifications/init', userData);
+
+  // Let the extensions know that the user is logged in
+  await onExtensionsReady(store);
 }
 
 /**

package/utils/back-off.ts

@@ -0,0 +1,176 @@
+type BackOffEntry = {
+  timeoutId?: NodeJS.Timeout,
+  try: number,
+  retries: number,
+  description: string,
+  metadata: any,
+}
+
+/**
+ * Helper class which handles backing off making the supplied request
+ *
+ * see `execute` for more info
+ */
+class BackOff {
+  private map: {
+   [id: string]: BackOffEntry
+  } = {};
+
+  private log(level: 'error' | 'info' | 'debug', id: string, classDescription: string, description: string, ...args: any[]) {
+    console[level](`BackOff... Id: "${ id }". Description: "${ description }"\nStatus: ${ classDescription }\n`, ...args); // eslint-disable-line no-console
+  }
+
+  /**
+   * Get a specific back off process
+   */
+  getBackOff(id: string): BackOffEntry {
+    return this.map[id];
+  }
+
+  /**
+   * Stop ALL back off processes started since the ui was loaded
+   */
+  resetAll() {
+    Object.keys(this.map).forEach((id) => {
+      this.reset(id);
+    });
+  }
+
+  /**
+   * Stop all back off process with a specific prefix
+   */
+  resetPrefix(prefix:string) {
+    Object.keys(this.map).forEach((id) => {
+      if (id.startsWith(prefix)) {
+        this.reset(id);
+      }
+    });
+  }
+
+  /**
+   * Stop a back off process with a specific id
+   */
+  reset(id: string) {
+    const backOff: BackOffEntry = this.map[id];
+
+    if (backOff) {
+      if (backOff?.timeoutId) {
+        this.log('info', id, 'Stopping (cancelling active back-off)', backOff.description);
+
+        clearTimeout(backOff.timeoutId);
+      }
+      this.log('debug', id, 'Reset', backOff.description);
+
+      delete this.map[id];
+    }
+  }
+
+  /**
+   * Call a function, but if it's recently been called delay execution aka back off
+   *
+   * This can be used in a totally disjoined asynchronous way
+   *
+   * 1. Request function A to be run
+   * 2. Entirely separate process requests function A to be run again
+   * 3. Back off process waits Xms and then runs function A again
+   * 4. Repeat steps 2 and 3, with an exponential increasing delay
+   *
+   * This can be called repeatedly, if the previous delay is still running new requests will be ignored
+   */
+  async execute<T = any>({
+    id, description, retries = 10, delayedFn, canFn = async() => true, metadata
+  }: {
+    /**
+     * Unique id for the execution of this function.
+     *
+     * This will be used to delay further executions, and also to cancel it
+     */
+    id: string,
+    /**
+     * Basic text description to use in logging
+     */
+    description: string,
+    /**
+     * Number of executions allowed before flatly refusing to call more. Defaults to 10
+     */
+    retries?: number,
+    /**
+     * Before calling delayedFn check if it can still run
+     *
+     * Useful for checking state after a looong delay
+     */
+    canFn?: () => Promise<boolean>,
+    /**
+     * Call this function
+     * - if it's not already waiting to run
+     * - if it's passed canFn
+     * - if it hasn't been tried over `retries` amount
+     *
+     * The function will be increasingly (exponentially) delayed if it has previously been called
+     */
+    delayedFn: () => Promise<any>,
+    /**
+     * Anything that might be important outside of this file (used with `getBackOff`)
+     */
+    metadata?: T,
+  }): Promise<NodeJS.Timeout | undefined> {
+    const backOff: BackOffEntry = this.map[id];
+
+    const cont = await canFn();
+
+    if (!cont) {
+      this.log('info', id, 'Skipping (can execute fn test failed)', description);
+
+      return undefined;
+    } else if (backOff?.timeoutId) {
+      this.log('info', id, 'Skipping (previous back off process still running)', description);
+
+      return backOff.timeoutId;
+    } else {
+      const backOffTry = backOff?.try || 0;
+
+      if (backOffTry + 1 > retries) {
+        this.log('error', id, 'Aborting (too many retries)', description);
+
+        return undefined;
+      }
+
+      // First step is immediate (0.001s)
+      // Second and others are exponential
+      // 1,      2,     3,  4,     5,  6,      7,   8,      9
+      // 1,      4,     9, 16,    25, 36,     49,  64,     81
+      // 0.25s, 1s, 2.25s, 4s, 6.25s, 9s, 12.25s, 16s, 20.25s
+      const delay = backOffTry === 0 ? 1 : Math.pow(backOffTry, 2) * 250;
+
+      this.log('info', id, `Delaying call (attempt ${ backOffTry + 1 }, delayed by ${ delay }ms)`, description);
+
+      const timeout = setTimeout(async() => {
+        try {
+          this.log('info', id, `Executing call`, description);
+
+          await delayedFn();
+        } catch (e) {
+          // Error occurred. Don't clear the map. Next time this is called we'll back off before trying ...
+          this.log('error', id, 'Failed call', description, e);
+        }
+
+        // Unblock future calls
+        delete this.map[id]?.timeoutId;
+      }, delay);
+
+      this.map[id] = {
+        timeoutId: timeout,
+        try:       backOff?.try ? backOff.try + 1 : 1,
+        retries,
+        description,
+        metadata
+      };
+
+      return timeout;
+    }
+  }
+}
+
+const backOff = new BackOff();
+
+export default backOff;

package/utils/cluster.js

@@ -6,7 +6,7 @@ import { SETTING } from '@shell/config/settings';
 import { PaginationFilterField, PaginationParamFilter } from '@shell/types/store/pagination.types';
 import { compare, sortable } from '@shell/utils/version';
 import { sortBy } from '@shell/utils/sort';
-import { SCHEDULING_CUSTOMIZATION } from '@shell/store/features';
+import { HARVESTER_CONTAINER, SCHEDULING_CUSTOMIZATION } from '@shell/store/features';
 import { _CREATE, _EDIT } from '@shell/config/query-params';
 import isEmpty from 'lodash/isEmpty';
 import { set } from '@shell/utils/object';
@@ -20,15 +20,13 @@ import { set } from '@shell/utils/object';
 export function paginationFilterClusters(store, filterMgmtCluster = true) {
   const paginationRequestFilters = [];
 
-  // Commenting out for the moment. This is broken for non-paginated world
-  // filterOnlyKubernetesClusters expects a mgmt cluster, however in the home page it's given a prov cluster
-  // note - filterHiddenLocalCluster works because it uses model isLocal which is on both cluster types
-  // const pFilterOnlyKubernetesClusters = paginationFilterOnlyKubernetesClusters(store);
-  // if (pFilterOnlyKubernetesClusters) {
-  //   paginationRequestFilters.push(pFilterOnlyKubernetesClusters);
-  // }
+  const pFilterOnlyKubernetesClusters = paginationFilterOnlyKubernetesClusters(store);
   const pFilterHiddenLocalCluster = paginationFilterHiddenLocalCluster(store, filterMgmtCluster);
 
+  if (pFilterOnlyKubernetesClusters) {
+    paginationRequestFilters.push(...pFilterOnlyKubernetesClusters);
+  }
+
   if (pFilterHiddenLocalCluster) {
     paginationRequestFilters.push(pFilterHiddenLocalCluster);
   }
@@ -77,37 +75,43 @@ export function paginationFilterHiddenLocalCluster(store, filterMgmtCluster = tr
  * @returns PaginationParam | null
  */
 export function paginationFilterOnlyKubernetesClusters(store) {
-  const openHarvesterContainerWorkload = store.getters['features/get']('harvester-baremetal-container-workload');
+  const openHarvesterContainerWorkload = store.getters['features/get'](HARVESTER_CONTAINER);
 
-  if (!openHarvesterContainerWorkload) {
+  if (openHarvesterContainerWorkload) {
+    // Show harvester clusters
     return null;
   }
 
-  return PaginationParamFilter.createMultipleFields([
-    new PaginationFilterField({
+  // Filter out harvester clusters
+  return [
+    PaginationParamFilter.createSingleField(new PaginationFilterField({
       field:  `metadata.labels[${ CAPI.PROVIDER }]`,
       equals: false,
       value:  VIRTUAL_HARVESTER_PROVIDER,
       exact:  true
-    }),
-    new PaginationFilterField({
+    })),
+    PaginationParamFilter.createSingleField(new PaginationFilterField({
       field:  `status.provider`,
       equals: false,
       value:  VIRTUAL_HARVESTER_PROVIDER,
       exact:  true
-    }),
-  ]);
+    }))
+  ];
 }
 
 /**
  * Filter out any clusters that are not Kubernetes Clusters
  **/
 export function filterOnlyKubernetesClusters(mgmtClusters, store) {
-  const openHarvesterContainerWorkload = store.getters['features/get']('harvester-baremetal-container-workload');
+  const openHarvesterContainerWorkload = store.getters['features/get'](HARVESTER_CONTAINER);
 
-  return mgmtClusters?.filter((c) => {
-    return openHarvesterContainerWorkload ? true : !isHarvesterCluster(c);
-  });
+  if (openHarvesterContainerWorkload) {
+    // Show harvester clusters
+    return mgmtClusters;
+  }
+
+  // Filter out harvester clusters
+  return mgmtClusters?.filter((c) => !isHarvesterCluster(c));
 }
 
 export function isHarvesterCluster(mgmtCluster) {