@rancher/shell 3.0.5-rc.3 → 3.0.5-rc.5

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

@@ -127,7 +127,7 @@ describe('class GitRepo', () => {
   describe('resourcesStatuses', () => {
     it.each([
       []
-    ])('foobat', () => {
+    ])('fn', () => {
       jest.spyOn(GitRepo.prototype, '$getters', 'get').mockReturnValue({ byId: jest.fn() });
 
       jest.spyOn(GitRepo.prototype, 'targetClusters', 'get').mockReturnValue([{

package/models/chart.js

@@ -1,9 +1,12 @@
-import { compatibleVersionsFor } from '@shell/store/catalog';
+import { compatibleVersionsFor, APP_UPGRADE_STATUS } from '@shell/store/catalog';
 import {
-  REPO_TYPE, REPO, CHART, VERSION, _FLAGGED, HIDE_SIDE_NAV
+  REPO_TYPE, REPO, CHART, VERSION, _FLAGGED, HIDE_SIDE_NAV, CATEGORY, TAG
 } from '@shell/config/query-params';
 import { BLANK_CLUSTER } from '@shell/store/store-types.js';
 import SteveModel from '@shell/plugins/steve/steve-class';
+import { CATALOG } from '@shell/config/types';
+import { CATALOG as CATALOG_ANNOTATIONS } from '@shell/config/labels-annotations';
+import day from 'dayjs';
 
 export default class Chart extends SteveModel {
   queryParams(from, hideSideNav) {
@@ -47,4 +50,143 @@ export default class Chart extends SteveModel {
       query,
     });
   }
+
+  /**
+   * Returns the list of installed apps that match this chart by:
+   * - chart name
+   * - repository name
+   * - and either:
+   *   - the home URL matches the latest version’s home URL
+   *   - or version + home URL match any other known version
+   *
+   * Inverse logic of `matchingCharts` in `catalog.cattle.io.app.js`.
+   *
+   * @returns {Array<Object>} List of matching installed app objects.
+   */
+  get matchingInstalledApps() {
+    const latestVersion = this.versions?.[0] || [];
+    const appHome = latestVersion?.home;
+    const installedApps = this.$rootGetters['cluster/all'](CATALOG.APP);
+
+    return installedApps.filter((installedApp) => {
+      const metadata = installedApp?.spec?.chart?.metadata;
+      const name = metadata?.name;
+      const version = metadata?.version;
+      const home = metadata?.home;
+
+      const repoName = metadata?.annotations?.[CATALOG_ANNOTATIONS.SOURCE_REPO_NAME] ||
+                       installedApp?.metadata?.labels?.[CATALOG_ANNOTATIONS.CLUSTER_REPO_NAME];
+
+      // name and repo should match
+      if (name !== this.chartName || !repoName || repoName !== this.repoName) {
+        return false;
+      }
+
+      // match by comparing home URL in the latest version vs home URL from the installed app
+      if (appHome && home === appHome) {
+        return true;
+      }
+
+      // match by version + home for the rest
+      return this.versions?.some((v) => v.version === version && home === appHome);
+    });
+  }
+
+  /**
+   * Determines if the chart is installed by checking if exactly one matching installed app is found.
+   *
+   * @returns {boolean} `true` if the chart is currently installed.
+   */
+  get isInstalled() {
+    return this.matchingInstalledApps.length === 1;
+  }
+
+  /**
+   * Determines if the installed app has a single available upgrade.
+   * Requires the chart to be installed.
+   *
+   * @returns {boolean} `true` if the app is installed and has a single upgrade available.
+   */
+  get upgradeable() {
+    return this.isInstalled && this.matchingInstalledApps[0].upgradeAvailable === APP_UPGRADE_STATUS.SINGLE_UPGRADE;
+  }
+
+  /**
+   * Builds structured metadata for display in RcItemCard.vue:
+   * - Sub-header (version and last updated)
+   * - Footer (repository, categories, tags)
+   * - Status indicators (e.g. deprecated, upgradeable, installed)
+   *
+   * @returns {Object} Card content object with `subHeaderItems`, `footerItems`, and `statuses` arrays.
+   */
+  get cardContent() {
+    if (!this._cardContent) {
+      const subHeaderItems = [
+        {
+          icon:        'icon-version-alt',
+          iconTooltip: { key: 'tableHeaders.version' },
+          label:       this.versions[0].version
+        },
+        {
+          icon:        'icon-refresh-alt',
+          iconTooltip: { key: 'tableHeaders.lastUpdated' },
+          label:       day(this.versions[0].created).format('MMM D, YYYY')
+        }
+      ];
+      const footerItems = [
+        {
+          type:        REPO,
+          icon:        'icon-repository-alt',
+          iconTooltip: { key: 'tableHeaders.repoName' },
+          labels:      [this.repoNameDisplay]
+        }
+      ];
+
+      if (this.categories.length) {
+        footerItems.push( {
+          type:        CATEGORY,
+          icon:        'icon-category-alt',
+          iconTooltip: { key: 'generic.category' },
+          labels:      this.categories
+        });
+      }
+
+      if (this.tags.length) {
+        footerItems.push({
+          type:        TAG,
+          icon:        'icon-tag-alt',
+          iconTooltip: { key: 'generic.tags' },
+          labels:      this.tags
+        });
+      }
+
+      const statuses = [];
+
+      if (this.deprecated) {
+        statuses.push({
+          icon: 'icon-alert-alt', color: 'error', tooltip: { key: 'generic.deprecated' }
+        });
+      }
+
+      if (this.upgradeable) {
+        statuses.push({
+          icon: 'icon-upgrade-alt', color: 'info', tooltip: { key: 'generic.upgradeable' }
+        });
+      }
+
+      if (this.isInstalled) {
+        statuses.push({
+          icon: 'icon-confirmation-alt', color: 'success', tooltip: { key: 'generic.installed' }
+        });
+      }
+
+      this._cardContent = {
+        subHeaderItems,
+        footerItems,
+        statuses
+      };
+    }
+
+    return this._cardContent;
+  }
 }

package/models/fleet-application.js

@@ -0,0 +1,385 @@
+import { convert, matching, convertSelectorObj } from '@shell/utils/selector';
+import jsyaml from 'js-yaml';
+import isEmpty from 'lodash/isEmpty';
+import { escapeHtml } from '@shell/utils/string';
+import { FLEET, MANAGEMENT } from '@shell/config/types';
+import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
+import { addObject, addObjects, findBy } from '@shell/utils/array';
+import SteveModel from '@shell/plugins/steve/steve-class';
+import { mapStateToEnum, primaryDisplayStatusFromCount, STATES_ENUM } from '@shell/plugins/dashboard-store/resource-class';
+import FleetUtils from '@shell/utils/fleet';
+
+export const MINIMUM_POLLING_INTERVAL = 15;
+export const DEFAULT_POLLING_INTERVAL = 60;
+
+function normalizeStateCounts(data) {
+  if (isEmpty(data)) {
+    return {
+      total:  0,
+      states: {},
+    };
+  }
+  const { desiredReady, ...rest } = data ;
+  const states = Object.entries(rest).reduce((res, [key, value]) => {
+    res[mapStateToEnum(key)] = value;
+
+    return res;
+  }, {});
+
+  return {
+    total: desiredReady,
+    states,
+  };
+}
+
+export default class FleetApplication extends SteveModel {
+  get currentUser() {
+    return this.$rootGetters['auth/v3User'] || {};
+  }
+
+  pause() {
+    this.spec.paused = true;
+    this.save();
+  }
+
+  unpause() {
+    this.spec.paused = false;
+    this.save();
+  }
+
+  enablePollingAction() {
+    this.spec.disablePolling = false;
+    this.save();
+  }
+
+  disablePollingAction() {
+    this.spec.disablePolling = true;
+    this.save();
+  }
+
+  goToClone() {
+    if (this.metadata?.labels?.[FLEET_ANNOTATIONS.CREATED_BY_USER_ID]) {
+      delete this.metadata.labels[FLEET_ANNOTATIONS.CREATED_BY_USER_ID];
+    }
+
+    if (this.metadata?.labels?.[FLEET_ANNOTATIONS.CREATED_BY_USER_NAME]) {
+      delete this.metadata.labels[FLEET_ANNOTATIONS.CREATED_BY_USER_NAME];
+    }
+
+    super.goToClone();
+  }
+
+  get isPollingEnabled() {
+    return !this.spec.disablePolling;
+  }
+
+  get state() {
+    if (this.spec?.paused === true) {
+      return 'paused';
+    }
+
+    return this.metadata?.state?.name || 'unknown';
+  }
+
+  get targetClusters() {
+    const workspace = this.$getters['byId'](FLEET.WORKSPACE, this.metadata.namespace);
+    const clusters = workspace?.clusters || [];
+    const groups = workspace?.clusterGroups || [];
+
+    if (workspace?.id === 'fleet-local') {
+      // should we be getting the clusters from workspace.clusters instead of having to rely on the groups,
+      // which takes an additional request to be done on the Fleet dashboard screen?
+      const local = findBy(groups, 'id', 'fleet-local/default');
+
+      if (local) {
+        return local.targetClusters;
+      }
+
+      return [];
+    }
+
+    if (!this.spec.targets) {
+      return [];
+    }
+
+    const out = [];
+
+    for (const tgt of this.spec.targets) {
+      if (tgt.clusterName) {
+        const cluster = findBy(clusters, 'metadata.name', tgt.clusterName);
+
+        if (cluster) {
+          addObject(out, cluster);
+        }
+      } else if (tgt.clusterGroup) {
+        const group = findBy(groups, {
+          'metadata.namespace': this.metadata.namespace,
+          'metadata.name':      tgt.clusterGroup,
+        });
+
+        if (group) {
+          addObjects(out, group.targetClusters);
+        }
+      } else if (tgt.clusterGroupSelector) {
+        const expressions = convertSelectorObj(tgt.clusterGroupSelector);
+        const matchingGroups = matching(groups, expressions);
+
+        for (const group of matchingGroups) {
+          addObjects(out, group.targetClusters);
+        }
+      } else if (tgt.clusterSelector) {
+        const expressions = convertSelectorObj(tgt.clusterSelector);
+        const matchingClusters = matching(clusters, expressions);
+
+        addObjects(out, matchingClusters);
+      }
+    }
+
+    return out;
+  }
+
+  get targetInfo() {
+    let mode = null;
+    let cluster = null;
+    let clusterGroup = null;
+    let advanced = null;
+
+    const targets = this.spec.targets || [];
+
+    advanced = jsyaml.dump(targets);
+
+    if (advanced === '[]\n') {
+      advanced = `# - name:
+#  clusterSelector:
+#    matchLabels:
+#     foo: bar
+#    matchExpressions:
+#     - key: foo
+#       op: In
+#       values: [bar, baz]
+#  clusterGroup: foo
+#  clusterGroupSelector:
+#    matchLabels:
+#     foo: bar
+#    matchExpressions:
+#     - key: foo
+#       op: In
+#       values: [bar, baz]
+`;
+    }
+
+    if (this.metadata.namespace === 'fleet-local') {
+      mode = 'local';
+    } else if (!targets.length) {
+      mode = 'none';
+    } else if (targets.length === 1) {
+      const target = targets[0];
+
+      if (Object.keys(target).length > 1) {
+        // There are multiple properties in a single target, so use the 'advanced' mode
+        // (otherwise any existing content is nuked for what we provide)
+        mode = 'advanced';
+      } else if (target.clusterGroup) {
+        clusterGroup = target.clusterGroup;
+
+        if (!mode) {
+          mode = 'clusterGroup';
+        }
+      } else if (target.clusterName) {
+        mode = 'cluster';
+        cluster = target.clusterName;
+      } else if (target.clusterSelector) {
+        if (Object.keys(target.clusterSelector).length === 0) {
+          mode = 'all';
+        } else {
+          const expressions = convert(target.clusterSelector.matchLabels, target.clusterSelector.matchExpressions);
+
+          if (expressions.length === 1 &&
+            expressions[0].key === FLEET_ANNOTATIONS.CLUSTER_NAME &&
+            expressions[0].operator === 'In' &&
+            expressions[0].values.length === 1
+          ) {
+            cluster = expressions[0].values[0];
+            if (!mode) {
+              mode = 'cluster';
+            }
+          }
+        }
+      }
+    }
+
+    if (!mode) {
+      mode = 'advanced';
+    }
+
+    return {
+      mode,
+      modeDisplay: this.t(`fleet.gitRepo.targetDisplay."${ mode }"`),
+      cluster,
+      clusterGroup,
+      advanced
+    };
+  }
+
+  get groupByLabel() {
+    const name = this.metadata.namespace;
+
+    if (name) {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.workspace', { name: escapeHtml(name) });
+    } else {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.notInAWorkspace');
+    }
+  }
+
+  get allResourceStatuses() {
+    return normalizeStateCounts(this.status?.resourceCounts || {});
+  }
+
+  statusResourceCountsForCluster(clusterId) {
+    if (!this.targetClusters.some((c) => c.id === clusterId)) {
+      return {};
+    }
+
+    return this.status?.perClusterResourceCounts[clusterId] || { desiredReady: 0 };
+  }
+
+  get resourcesStatuses() {
+    if (isEmpty(this.status?.resources)) {
+      return [];
+    }
+
+    const clusters = (this.targetClusters || []).reduce((res, c) => {
+      res[c.id] = c;
+
+      return res;
+    }, {});
+
+    const resources = this.status?.resources?.reduce((acc, resourceInfo) => {
+      const { perClusterState, ...resource } = resourceInfo;
+
+      if (Object.entries(perClusterState).length === 0) {
+        (this.targetClusters || []).forEach((cluster) => {
+          acc.push(Object.assign({}, resource, { clusterId: cluster.id, state: resource.state }));
+        });
+      } else {
+        Object.entries(perClusterState).forEach(([state, clusterIds]) => {
+          clusterIds.filter((id) => !!clusters[id]).forEach((clusterId) => {
+            acc.push(Object.assign({}, resource, { clusterId, state }));
+          });
+        });
+      }
+
+      return acc;
+    }, []);
+
+    return resources.map((r) => {
+      const { namespace, name, clusterId } = r;
+      const type = FleetUtils.resourceType(r);
+      const c = clusters[clusterId];
+
+      return {
+        key: `${ clusterId }-${ type }-${ namespace }-${ name }`,
+
+        // Needed?
+        id: FleetUtils.resourceId(r),
+        type,
+        clusterId,
+
+        // columns, see FleetResources.vue
+        state:       mapStateToEnum(r.state),
+        clusterName: c.nameDisplay,
+        apiVersion:  r.apiVersion,
+        kind:        r.kind,
+        name,
+        namespace,
+
+        // other properties
+        detailLocation: FleetUtils.detailLocation(r, c.metadata.labels[FLEET_ANNOTATIONS.CLUSTER_NAME]),
+      };
+    });
+  }
+
+  get clusterInfo() {
+    const ready = this.status?.readyClusters || 0;
+    const total = this.status?.desiredReadyClusters || 0;
+
+    return {
+      ready,
+      unready: total - ready,
+      total,
+    };
+  }
+
+  clusterState(clusterId) {
+    const resourceCounts = this.statusResourceCountsForCluster(clusterId);
+
+    return primaryDisplayStatusFromCount(resourceCounts) || STATES_ENUM.ACTIVE;
+  }
+
+  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;
+  }
+
+  get clustersList() {
+    return this.$getters['all'](FLEET.CLUSTER);
+  }
+
+  get readyClusters() {
+    return this.status?.readyClusters || 0;
+  }
+
+  get _detailLocation() {
+    return {
+      ...super._detailLocation,
+      name: 'c-cluster-fleet-application-resource-namespace-id'
+    };
+  }
+
+  get doneOverride() {
+    return {
+      ...super.listLocation,
+      name: 'c-cluster-fleet-application'
+    };
+  }
+
+  get doneRoute() {
+    return this.doneOverride?.name;
+  }
+
+  get parentNameOverride() {
+    return this.$rootGetters['i18n/t'](`typeLabel."${ FLEET.APPLICATION }"`, { count: 1 })?.trim();
+  }
+}

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

@@ -1,6 +1,5 @@
 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, MANAGEMENT } from '@shell/config/types';
 import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
@@ -11,18 +10,20 @@ export default class FleetBundle extends SteveModel {
     return this.status?.conditions?.[0].lastUpdateTime;
   }
 
-  get bundleType() {
-    if (typeHelper.memberOfObject(this.spec, 'helm')) {
-      return 'helm';
-    }
+  get repoName() {
+    const labels = this.metadata?.labels || {};
 
-    return '';
+    return labels[FLEET_ANNOTATIONS.REPO_NAME];
   }
 
-  get repoName() {
+  get helmName() {
     const labels = this.metadata?.labels || {};
 
-    return labels[FLEET_ANNOTATIONS.REPO_NAME];
+    return labels[FLEET_ANNOTATIONS.HELM_NAME];
+  }
+
+  get appSourceName() {
+    return this.helmName || this.repoName;
   }
 
   get targetClusters() {