@rancher/shell 3.0.2-rc.5 → 3.0.2

package/models/__tests__/fleet.cattle.io.gitrepo.test.ts

@@ -0,0 +1,157 @@
+import GitRepo from '@shell/models/fleet.cattle.io.gitrepo.js';
+
+const status = {
+  commit:     'foo',
+  conditions: [
+    {
+      error:          true,
+      lastUpdateTime: '2025-02-28T15:39:52Z',
+      message:        'Modified(1) [Cluster fleet-local/local]; configmap.v1 lots-a/test-config-one missing',
+      status:         'False',
+      transitioning:  true,
+      type:           'Ready'
+    },
+    {
+      error:          false,
+      lastUpdateTime: '2025-02-28T15:36:25Z',
+      status:         'True',
+      transitioning:  false,
+      type:           'GitPolling'
+    },
+    {
+      error:          false,
+      lastUpdateTime: '2025-02-28T15:36:25Z',
+      status:         'False',
+      transitioning:  false,
+      type:           'Reconciling'
+    },
+    {
+      error:          false,
+      lastUpdateTime: '2025-02-28T15:36:25Z',
+      status:         'False',
+      transitioning:  false,
+      type:           'Stalled'
+    },
+    {
+      error:          false,
+      lastUpdateTime: '2025-02-28T15:36:25Z',
+      status:         'True',
+      transitioning:  false,
+      type:           'Accepted'
+    }
+  ],
+  desiredReadyClusters: 1,
+  display:              {
+    readyBundleDeployments: '1/2',
+    state:                  'Modified'
+  },
+  gitJobStatus:             'Current',
+  lastPollingTriggered:     '2025-02-28T16:08:39Z',
+  observedGeneration:       1,
+  perClusterResourceCounts: {
+    'fleet-local/local': {
+      desiredReady: 2,
+      missing:      1,
+      modified:     0,
+      notReady:     0,
+      orphaned:     0,
+      ready:        2,
+      unknown:      0,
+      waitApplied:  0
+    }
+  },
+  readyClusters:  0,
+  resourceCounts: {
+    desiredReady: 2,
+    missing:      1,
+    modified:     0,
+    notReady:     0,
+    orphaned:     0,
+    ready:        2,
+    unknown:      0,
+    waitApplied:  0
+  },
+  resources: [
+    {
+      apiVersion:      'v1',
+      id:              'lots-a/test-config-one',
+      kind:            'ConfigMap',
+      name:            'test-config-one',
+      namespace:       'lots-a',
+      perClusterState: {
+        missing: [
+          'fleet-local/local'
+        ]
+      },
+      state: 'Missing',
+      type:  'configmap'
+    },
+    {
+      apiVersion:      'v1',
+      id:              'lots-a/test-config-two',
+      kind:            'ConfigMap',
+      name:            'test-config-two',
+      namespace:       'lots-a',
+      perClusterState: {
+        ready: [
+          'fleet-local/local'
+        ]
+      },
+      state: 'Ready',
+      type:  'configmap'
+    },
+  ],
+  summary: {
+    desiredReady:      2,
+    modified:          1,
+    nonReadyResources: [
+      {
+        bundleState:    'Modified',
+        modifiedStatus: [
+          {
+            apiVersion: 'v1',
+            kind:       'ConfigMap',
+            missing:    true,
+            name:       'test-config-one',
+            namespace:  'lots-a'
+          }
+        ],
+        name: 'lots-a-scale-lotsofbundles-one'
+      }
+    ],
+    ready: 1
+  }
+};
+
+describe('class GitRepo', () => {
+  describe('resourcesStatuses', () => {
+    it.each([
+      []
+    ])('foobat', () => {
+      jest.spyOn(GitRepo.prototype, '$getters', 'get').mockReturnValue({ byId: jest.fn() });
+
+      jest.spyOn(GitRepo.prototype, 'targetClusters', 'get').mockReturnValue([{
+        id:       'fleet-local/local',
+        metadata: { labels: {} }
+      }]);
+
+      const gitRepo = new GitRepo({
+        metadata: { namespace: 'fleet-local' },
+        spec:     {},
+        status
+      });
+
+      const resourcesStatuses = gitRepo.resourcesStatuses;
+
+      const resource1 = resourcesStatuses.find((el: any) => el.id === 'lots-a/test-config-one');
+
+      expect(resource1.state).toStrictEqual('missing');
+      expect(resource1.detailLocation).toBeUndefined();
+
+      const resource2 = resourcesStatuses.find((el: any) => el.id === 'lots-a/test-config-two');
+
+      expect(resource2.state).toStrictEqual('ready');
+      expect(resource2.detailLocation).toBeDefined();
+    });
+  });
+});

package/models/__tests__/secret.test.ts

@@ -1,37 +1,80 @@
 import Secret from '@shell/models/secret';
+import { SECRET_TYPES as TYPES } from '@shell/config/secret';
 
 describe('class Secret', () => {
-  it('should contains the type attribute if cleanForDownload', async() => {
-    const secret = new Secret({});
-    const yaml = `apiVersion: v1
+  describe('cleanForDownload', () => {
+    it('should contains the type attribute if cleanForDownload', async() => {
+      const secret = new Secret({});
+      const yaml = `apiVersion: v1
 kind: Secret
 metadata:
   name: my-secret
 type: Opaque
 `;
-    const cleanYaml = await secret.cleanForDownload(yaml);
+      const cleanYaml = await secret.cleanForDownload(yaml);
 
-    expect(cleanYaml).toBe(yaml);
-  });
+      expect(cleanYaml).toBe(yaml);
+    });
 
-  it('should remove id, links and actions keys if cleanForDownload', async() => {
-    const secret = new Secret({});
-    const expectedYamlStr = `apiVersion: v1
+    it('should remove id, links and actions keys if cleanForDownload', async() => {
+      const secret = new Secret({});
+      const expectedYamlStr = `apiVersion: v1
 kind: Secret
 metadata:
   name: my-secret
   namespace: default
 type: Opaque
 `;
-    const part = `id: test_id
+      const part = `id: test_id
 links:
   view: https://example.com
 actions:
   remove: https://example.com`;
-    const yaml = `${ expectedYamlStr }
+      const yaml = `${ expectedYamlStr }
 ${ part }`;
-    const cleanYaml = await secret.cleanForDownload(yaml);
+      const cleanYaml = await secret.cleanForDownload(yaml);
+
+      expect(cleanYaml).toBe(expectedYamlStr);
+    });
+  });
+
+  describe('supportsSshKnownHosts', () => {
+    it.each([
+      [
+        false,
+        'type is not SSH',
+        'generic',
+        { known_hosts: 'S05PV05fSE9TVFM=' },
+      ],
+      [
+        false,
+        'missing known_hosts',
+        TYPES.SSH,
+        {},
+      ],
+      [
+        false,
+        'data is null',
+        TYPES.SSH,
+        null,
+      ],
+      [
+        true,
+        'type is SSH key and known_hosts exists',
+        TYPES.SSH,
+        { known_hosts: 'S05PV05fSE9TVFM=' },
+      ],
+    ])('is %p if %p', (
+      supported,
+      descr,
+      _type,
+      data
+    ) => {
+      const secret = new Secret({ _type, data });
+
+      const result = secret.supportsSshKnownHosts;
 
-    expect(cleanYaml).toBe(expectedYamlStr);
+      expect(result).toBe(supported);
+    });
   });
 });

package/models/catalog.cattle.io.app.js

@@ -9,7 +9,7 @@ import { SHOW_PRE_RELEASE } from '@shell/store/prefs';
 import { set } from '@shell/utils/object';
 
 import SteveModel from '@shell/plugins/steve/steve-class';
-import { compatibleVersionsFor } from '@shell/store/catalog';
+import { compatibleVersionsFor, APP_UPGRADE_STATUS } from '@shell/store/catalog';
 
 export default class CatalogApp extends SteveModel {
   showMasthead(mode) {
@@ -22,6 +22,7 @@ export default class CatalogApp extends SteveModel {
     set(this, 'skipCRDs', false);
     set(this, 'timeout', 300);
     set(this, 'wait', true);
+    set(this, 'upgradeAvailableVersion', '');
   }
 
   get _availableActions() {
@@ -40,7 +41,7 @@ export default class CatalogApp extends SteveModel {
   }
 
   get warnDeletionMessage() {
-    if (this.upgradeAvailable === false) {
+    if (this.upgradeAvailable === APP_UPGRADE_STATUS.NOT_APPLICABLE) {
       const manager = this.spec?.chart?.metadata?.annotations?.[CATALOG_ANNOTATIONS.MANAGED] || 'Rancher';
 
       return this.t('catalog.delete.warning.managed', { manager: manager === 'true' ? 'Rancher' : manager, name: this.name });
@@ -49,25 +50,56 @@ export default class CatalogApp extends SteveModel {
     return null;
   }
 
-  matchingChart(includeHidden) {
+  /**
+   * Finds matching charts based on the current chart's name, repository, and other attributes.
+   * The function filters out charts that do not meet specific criteria, including version and home value matches.
+   *
+   * @param includeHidden - Whether to include hidden charts in the search.
+   * @returns An array of matching chart objects that meet the specified criteria.
+  */
+  matchingCharts(includeHidden) {
     const chart = this.spec?.chart;
 
     if ( !chart ) {
-      return;
+      return [];
     }
 
     const chartName = chart.metadata?.name;
     const repoName = chart.metadata?.annotations?.[CATALOG_ANNOTATIONS.SOURCE_REPO_NAME] || this.metadata?.labels?.[CATALOG_ANNOTATIONS.CLUSTER_REPO_NAME];
-    const preferRepoType = chart.metadata?.annotations?.[CATALOG_ANNOTATIONS.SOURCE_REPO_TYPE] || 'cluster';
 
-    const match = this.$rootGetters['catalog/chart']({
+    const matchingCharts = this.$rootGetters['catalog/chart']({
       chartName,
       repoName,
-      preferRepoType,
-      includeHidden
+      includeHidden,
+      multiple: true
+    }) || [];
+
+    if (matchingCharts.length === 0) {
+      return [];
+    }
+
+    // Filtering matches by verifying if the current version is in the matched chart's available versions, and that the home value matches as well
+    const thisHome = chart?.metadata?.home;
+    const bestMatches = matchingCharts.filter(({ versions }) => {
+      // First checking if the latest version has the same home value
+      if (thisHome === versions[0]?.home) {
+        return true;
+      }
+
+      for (let i = 1; i < versions.length; i++) {
+        const { version, home } = versions[i];
+
+        // Finding the exact version, if the version is not there, then most likely it's not a match
+        // if the exact version is found, then we can compare the home value
+        if (version === this.currentVersion && (home === thisHome)) {
+          return true;
+        }
+      }
+
+      return false;
     });
 
-    return match;
+    return bestMatches;
   }
 
   get currentVersion() {
@@ -75,28 +107,42 @@ export default class CatalogApp extends SteveModel {
   }
 
   get upgradeAvailable() {
-    // false = does not apply (managed by fleet)
-    // null = no upgrade found
-    // object = version available to upgrade to
+    // one of the following statuses gets returned:
+    // NOT_APPLICABLE - managed by fleet
+    // NO_UPGRADE - no upgrade found
+    // SINGLE_UPGRADE - a version available to upgrade to
+    // MULTIPLE_UPGRADES - more than one match found
 
     if (
       this.spec?.chart?.metadata?.annotations?.[CATALOG_ANNOTATIONS.MANAGED] ||
       this.spec?.chart?.metadata?.annotations?.[FLEET.BUNDLE_ID]
     ) {
       // Things managed by fleet shouldn't show upgrade available even if there might be.
-      return false;
+      return APP_UPGRADE_STATUS.NOT_APPLICABLE;
     }
-    const chart = this.matchingChart(false);
 
-    if ( !chart ) {
-      return null;
+    const charts = this.matchingCharts(false);
+
+    if (charts.length === 0) {
+      return APP_UPGRADE_STATUS.NO_UPGRADE;
     }
 
-    const workerOSs = this.$rootGetters['currentCluster'].workerOSs;
+    // Handle single chart logic
+    if (charts.length === 1) {
+      return this.evaluateUpgradeForChart(charts[0]);
+    }
 
+    // Handle multiple upgrade matches
+    return this.handleMultipleUpgradeMatches(charts);
+  }
+
+  /**
+   * Evaluates upgrade status for a single chart.
+   */
+  evaluateUpgradeForChart(chart) {
+    const workerOSs = this.$rootGetters['currentCluster'].workerOSs;
     const showPreRelease = this.$rootGetters['prefs/get'](SHOW_PRE_RELEASE);
 
-    const thisVersion = this.spec?.chart?.metadata?.version;
     let versions = chart.versions;
 
     if (!showPreRelease) {
@@ -108,45 +154,75 @@ export default class CatalogApp extends SteveModel {
     const newestChart = versions?.[0];
     const newestVersion = newestChart?.version;
 
-    if ( !thisVersion || !newestVersion ) {
-      return null;
+    if (!this.currentVersion || !newestVersion) {
+      return APP_UPGRADE_STATUS.NO_UPGRADE;
     }
 
-    if ( compare(thisVersion, newestVersion) < 0 ) {
-      return cleanupVersion(newestVersion);
+    if (compare(this.currentVersion, newestVersion) < 0) {
+      // Set the available upgrade version to be used in other places
+      this.upgradeAvailableVersion = cleanupVersion(newestVersion);
+
+      return APP_UPGRADE_STATUS.SINGLE_UPGRADE;
     }
 
-    return null;
+    return APP_UPGRADE_STATUS.NO_UPGRADE;
   }
 
-  get upgradeAvailableSort() {
-    const version = this.upgradeAvailable;
+  /**
+   * Handles the case where multiple upgrade matches are found.
+   * @param charts - Array of matching charts
+   */
+  handleMultipleUpgradeMatches(charts) {
+    const qualifiedCharts = [];
+
+    for (const chart of charts) {
+      const status = this.evaluateUpgradeForChart(chart);
 
-    if ( !version ) {
-      return '~'; // Tilde sorts after all numbers and letters
+      if (status === APP_UPGRADE_STATUS.SINGLE_UPGRADE) {
+        qualifiedCharts.push(chart);
+      }
+    }
+
+    if (qualifiedCharts.length > 1) {
+      return APP_UPGRADE_STATUS.MULTIPLE_UPGRADES;
+    }
+
+    if (qualifiedCharts.length === 1) {
+      const newestVersion = qualifiedCharts[0]?.versions?.[0]?.version;
+
+      this.upgradeAvailableVersion = cleanupVersion(newestVersion);
+
+      return APP_UPGRADE_STATUS.SINGLE_UPGRADE;
+    }
+
+    return APP_UPGRADE_STATUS.NO_UPGRADE;
+  }
+
+  get upgradeAvailableSort() {
+    if (this.upgradeAvailable === APP_UPGRADE_STATUS.SINGLE_UPGRADE) {
+      return sortable(this.upgradeAvailableVersion);
     }
 
-    return sortable(version);
+    return '~'; // Tilde sorts after all numbers and letters
   }
 
   get currentVersionCompatible() {
     const workerOSs = this.$rootGetters['currentCluster'].workerOSs;
 
-    const chart = this.matchingChart(false);
-    const thisVersion = this.spec?.chart?.metadata?.version;
+    const chart = this.matchingCharts(false)[0];
 
     if (!chart) {
       return true;
     }
 
-    const versionInChart = chart.versions.find((version) => version.version === thisVersion);
+    const versionInChart = chart.versions.find((version) => version.version === this.currentVersion);
 
     if (!versionInChart) {
       return true;
     }
     const compatibleVersions = compatibleVersionsFor(chart, workerOSs, true) || [];
 
-    const thisVersionCompatible = !!compatibleVersions.find((version) => version.version === thisVersion);
+    const thisVersionCompatible = !!compatibleVersions.find((version) => version.version === this.currentVersion);
 
     return thisVersionCompatible;
   }
@@ -155,7 +231,7 @@ export default class CatalogApp extends SteveModel {
     if (this.currentVersionCompatible) {
       return null;
     }
-    if (this.upgradeAvailable) {
+    if (this.upgradeAvailableVersion) {
       return this.t('catalog.os.versionIncompatible');
     }
 
@@ -163,12 +239,11 @@ export default class CatalogApp extends SteveModel {
   }
 
   goToUpgrade(forceVersion, fromTools) {
-    const match = this.matchingChart(true);
-    const versionName = this.spec?.chart?.metadata?.version;
+    const match = this.matchingCharts(true)[0];
     const query = {
       [NAMESPACE]: this.metadata.namespace,
       [NAME]:      this.metadata.name,
-      [VERSION]:   forceVersion || versionName,
+      [VERSION]:   forceVersion || this.currentVersion,
     };
 
     if ( match ) {
@@ -223,7 +298,7 @@ export default class CatalogApp extends SteveModel {
   }
 
   get versionDisplay() {
-    return cleanupVersion(this.spec?.chart?.metadata?.version);
+    return cleanupVersion(this.currentVersion);
   }
 
   get versionSort() {

package/models/cluster.js

@@ -1,4 +1,5 @@
 import NormanModel from '@shell/plugins/steve/norman-class';
+import { CAPI } from '@shell/config/types';
 
 export const LABEL_CONTAINS_PROTECTED = [
   'io.cattle.lifecycle',
@@ -13,6 +14,7 @@ export const ANNOTATIONS_CONTAINS_PROTECTED = [
   'k3s.io',
   'kubernetes.io',
   'k3s.io',
+  'rancher.io'
 ];
 export default class NormanCluster extends NormanModel {
   get systemLabels() {
@@ -30,4 +32,13 @@ export default class NormanCluster extends NormanModel {
   get hasSystemAnnotations() {
     return !!(this.systemAnnotations || []).length;
   }
+
+  waitForProvisioning(timeout = 60000, interval) {
+    return this.waitForTestFn(() => {
+      const ns = this.annotations['objectset.rio.cattle.io/owner-namespace'] || 'fleet-default';
+      const id = `${ ns }/${ this.id }`;
+
+      return id && !!this.$rootGetters['management/byId'](CAPI.RANCHER_CLUSTER, id);
+    }, this.$rootGetters['i18n/t']('cluster.managementTimeout'), timeout, interval);
+  }
 }

package/models/fleet.cattle.io.bundle.js

@@ -2,7 +2,8 @@ import { escapeHtml, ucFirst } from '@shell/utils/string';
 import SteveModel from '@shell/plugins/steve/steve-class';
 import typeHelper from '@shell/utils/type-helpers';
 import { addObject, addObjects, findBy } from '@shell/utils/array';
-import { FLEET } from '@shell/config/types';
+import { FLEET, MANAGEMENT } from '@shell/config/types';
+import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
 import { convertSelectorObj, matching } from '@shell/utils/selector';
 
 export default class FleetBundle extends SteveModel {
@@ -21,7 +22,7 @@ export default class FleetBundle extends SteveModel {
   get repoName() {
     const labels = this.metadata?.labels || {};
 
-    return labels['fleet.cattle.io/repo-name'];
+    return labels[FLEET_ANNOTATIONS.REPO_NAME];
   }
 
   get targetClusters() {
@@ -127,4 +128,41 @@ export default class FleetBundle extends SteveModel {
       );
     }
   }
+
+  get authorId() {
+    return this.metadata?.labels?.[FLEET_ANNOTATIONS.CREATED_BY_USER_ID];
+  }
+
+  get author() {
+    if (this.authorId) {
+      return this.$rootGetters['management/byId'](MANAGEMENT.USER, this.authorId);
+    }
+
+    return null;
+  }
+
+  get createdBy() {
+    const displayName = this.metadata?.labels?.[FLEET_ANNOTATIONS.CREATED_BY_USER_NAME];
+
+    if (!displayName) {
+      return null;
+    }
+
+    return {
+      displayName,
+      location: !this.author ? null : {
+        name:   'c-cluster-product-resource-id',
+        params: {
+          cluster:  '_',
+          product:  'auth',
+          resource: MANAGEMENT.USER,
+          id:       this.author.id,
+        }
+      }
+    };
+  }
+
+  get showCreatedBy() {
+    return !!this.createdBy;
+  }
 }