@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.4

package/models/cluster.x-k8s.io.machineset.js

@@ -1,23 +1,5 @@
-import { CAPI } from '@shell/config/types';
-import { escapeHtml } from '@shell/utils/string';
-import SteveModel from '@shell/plugins/steve/steve-class';
 
-export default class CapiMachineSet extends SteveModel {
-  get cluster() {
-    if ( !this.spec.clusterName ) {
-      return null;
-    }
+import CapiMachineRoot from '@shell/models/base-cluster.x-k8s.io';
 
-    const clusterId = `${ this.metadata.namespace }/${ this.spec.clusterName }`;
-
-    const cluster = this.$rootGetters['management/byId'](CAPI.RANCHER_CLUSTER, clusterId);
-
-    return cluster;
-  }
-
-  get groupByLabel() {
-    const name = this.cluster?.nameDisplay || this.spec.clusterName;
-
-    return this.$rootGetters['i18n/t']('resourceTable.groupLabel.cluster', { name: escapeHtml(name) });
-  }
+export default class CapiMachineSet extends CapiMachineRoot {
 }

package/models/compliance.cattle.io.clusterscan.js

@@ -65,8 +65,29 @@ export default class ClusterScan extends SteveModel {
       total:   1,
     };
 
+    const downloadReportXCCDF = {
+      action:  'downloadLatestReportXCCDF',
+      enabled: this.hasReport,
+      icon:    'icon icon-download',
+      label:   t('compliance.downloadReportXCCDF'),
+      total:   1,
+    };
+
+    const downloadAllReportsXCCDF = {
+      action:  'downloadAllReportsXCCDF',
+      enabled: this.hasReport,
+      icon:    'icon icon-download',
+      label:   t('compliance.downloadAllReportsXCCDF'),
+      total:   1,
+    };
+
     if (this.hasReports) {
       out.unshift({ divider: true });
+      if (this.spec?.scheduledScanConfig?.cronSchedule) {
+        out.unshift(downloadAllReportsXCCDF);
+        downloadReportXCCDF.label = t('compliance.downloadLatestReportXCCDF');
+      }
+      out.unshift(downloadReportXCCDF);
       if (this.spec?.scheduledScanConfig?.cronSchedule) {
         out.unshift(downloadAllReports);
         downloadReport.label = t('compliance.downloadLatestReport');
@@ -121,7 +142,7 @@ export default class ClusterScan extends SteveModel {
 
       downloadFile(`${ labelFor(report) }.csv`, csv, 'application/csv');
     } catch (err) {
-      this.$dispatch('growl/fromError', { title: 'Error downloading file', err }, { root: true });
+      this.$dispatch('growl/fromError', { title: this.t('compliance.scan.errorDownload'), err }, { root: true });
     }
   }
 
@@ -143,7 +164,7 @@ export default class ClusterScan extends SteveModel {
 
         toZip[`${ labelFor(report) }.csv`] = csv;
       } catch (err) {
-        this.$dispatch('growl/fromError', { title: 'Error downloading file', err }, { root: true });
+        this.$dispatch('growl/fromError', { title: this.t('compliance.scan.errorDownload'), err }, { root: true });
       }
     });
     if (!isEmpty(toZip)) {
@@ -153,6 +174,148 @@ export default class ClusterScan extends SteveModel {
     }
   }
 
+  async _resolveBenchmark() {
+    const profileName = this.status?.lastRunScanProfileName;
+
+    if (!profileName) {
+      return null;
+    }
+    const profile = await this.$dispatch('find', { type: COMPLIANCE.CLUSTER_SCAN_PROFILE, id: profileName });
+    const benchmarkId = profile?.spec?.benchmarkVersion;
+
+    if (!benchmarkId) {
+      return null;
+    }
+
+    return this.$dispatch('find', { type: COMPLIANCE.BENCHMARK, id: benchmarkId });
+  }
+
+  // Fetches the kube-bench profile ConfigMap referenced by the benchmark and
+  // parses its metadata.yaml data key. Top-level fields become the XCCDF
+  // benchmark metadata; the checks: map becomes per-check decorations
+  // (framework-agnostic; STIG, CIS, BSI, etc. all populate the same shape).
+  async _resolveExportMetadata(benchmark) {
+    const name = benchmark?.spec?.customBenchmarkConfigMapName;
+    const namespace = benchmark?.spec?.customBenchmarkConfigMapNamespace;
+    const empty = { metadata: {}, decorations: {} };
+
+    if (!name || !namespace) {
+      return empty;
+    }
+
+    try {
+      const cm = await this.$dispatch('find', { type: 'configmap', id: `${ namespace }/${ name }` });
+      const raw = cm?.data?.['metadata.yaml'];
+
+      if (!raw) {
+        return empty;
+      }
+
+      const jsyaml = await import(/* webpackChunkName: "js-yaml" */'js-yaml');
+      const parsed = jsyaml.load(raw) || {};
+      const { checks = {}, ...rest } = parsed;
+
+      return { metadata: rest, decorations: checks };
+    } catch (e) {
+      console.error('[_resolveExportMetadata] failed to fetch or parse benchmark ConfigMap:', e); // eslint-disable-line no-console
+
+      return empty;
+    }
+  }
+
+  async downloadLatestReportXCCDF() {
+    const reports = await this.getReports() || [];
+    const report = sortBy(reports, 'metadata.creationTimestamp', true)[0];
+
+    try {
+      const benchmark = await this._resolveBenchmark();
+      const { metadata, decorations } = await this._resolveExportMetadata(benchmark);
+      const { generateXCCDFPerNode } = await import(/* webpackChunkName: "xccdf" */'@shell/utils/xccdf');
+
+      const parsed = report.parsedReport || {};
+      const common = {
+        report:           parsed,
+        benchmarkVersion: parsed.version || benchmark?.spec?.benchmarkVersion || '',
+        metadata,
+        decorations,
+      };
+
+      const toZip = {};
+
+      if (!Object.entries(parsed.nodes || {}).length) {
+        this.$dispatch('growl/fromError', { title: this.t('compliance.scan.errorNoParsedNodes') }, { root: true });
+      } else {
+        Object.entries(parsed.nodes || {}).forEach(([role, hosts]) => {
+          (hosts || []).forEach((hostname) => {
+            const xml = generateXCCDFPerNode({
+              ...common, hostname, role,
+            });
+
+            toZip[`${ labelFor(report) }--${ hostname }.xml`] = xml;
+          });
+        });
+
+        if (!isEmpty(toZip)) {
+          const zip = await generateZip(toZip);
+
+          downloadFile(`${ labelFor(report) }-per-node.zip`, zip, 'application/zip');
+        }
+      }
+    } catch (err) {
+      this.$dispatch('growl/fromError', { title: this.t('compliance.scan.errorDownload'), err }, { root: true });
+    }
+  }
+
+  async downloadAllReportsXCCDF() {
+    const toZip = {};
+    const reports = await this.getReports() || [];
+
+    try {
+      const benchmark = await this._resolveBenchmark();
+      const { metadata, decorations } = await this._resolveExportMetadata(benchmark);
+      const { generateXCCDFPerNode } = await import(/* webpackChunkName: "xccdf" */'@shell/utils/xccdf');
+
+      const hasParsedNodes = reports.some((report) => Object.entries(report.parsedReport?.nodes || {}).length);
+
+      if (!hasParsedNodes) {
+        this.$dispatch('growl/fromError', { title: this.t('compliance.scan.errorNoParsedNodes') }, { root: true });
+      } else {
+        reports.forEach((report) => {
+          try {
+            const parsed = report.parsedReport || {};
+            const common = {
+              report:           parsed,
+              benchmarkVersion: parsed.version || benchmark?.spec?.benchmarkVersion || '',
+              metadata,
+              decorations,
+            };
+            const folder = labelFor(report);
+
+            Object.entries(parsed.nodes || {}).forEach(([role, hosts]) => {
+              (hosts || []).forEach((hostname) => {
+                const xml = generateXCCDFPerNode({
+                  ...common, hostname, role,
+                });
+
+                toZip[`${ folder }/${ hostname }.xml`] = xml;
+              });
+            });
+          } catch (err) {
+            this.$dispatch('growl/fromError', { title: this.t('compliance.scan.errorDownload'), err }, { root: true });
+          }
+        });
+
+        if (!isEmpty(toZip)) {
+          generateZip(toZip).then((zip) => {
+            downloadFile(`${ this.id }-reports-xccdf-per-node.zip`, zip, 'application/zip');
+          });
+        }
+      }
+    } catch (err) {
+      this.$dispatch('growl/fromError', { title: this.t('compliance.scan.errorDownload'), err }, { root: true });
+    }
+  }
+
   get scanProfileLink() {
     if (this.status?.lastRunScanProfileName) {
       return {

package/models/ext.cattle.io.kubeconfig.ts

@@ -1,4 +1,4 @@
-import { CAPI, MANAGEMENT } from '@shell/config/types';
+import { MANAGEMENT } from '@shell/config/types';
 import SteveModel from '@shell/plugins/steve/steve-class';
 import { Location } from 'vue-router';
 
@@ -49,16 +49,13 @@ export default class Kubeconfig extends SteveModel {
    */
   get referencedClusters(): ReferencedCluster[] {
     const clusterIds = this.spec?.clusters || [];
-    const provClusters = this.$rootGetters['management/all'](CAPI.RANCHER_CLUSTER) || [];
-    const mgmtClusters = this.$rootGetters['management/all'](MANAGEMENT.CLUSTER) || [];
 
     return clusterIds.map((id: string) => {
-      const provCluster = provClusters.find((c: any) => c.mgmt?.id === id || c.status?.clusterName === id);
-      const mgmtCluster = mgmtClusters.find((c: any) => c.id === id);
-      const cluster = provCluster || mgmtCluster;
+      const mgmtCluster = this.$rootGetters['management/byId'](MANAGEMENT.CLUSTER, id);
+      const provCluster = mgmtCluster?.provCluster;
 
       return {
-        label:    cluster?.nameDisplay || this.t('"ext.cattle.io.kubeconfig".deleted', { name: id }),
+        label:    mgmtCluster?.nameDisplay || this.t('"ext.cattle.io.kubeconfig".deleted', { name: id }),
         location: provCluster?.detailLocation || mgmtCluster?.detailLocation || null
       };
     });

package/models/fleet-application.js

@@ -7,6 +7,7 @@ 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';
+import { HARVESTER_CONTAINER } from '@shell/store/features';
 
 function normalizeStateCounts(data) {
   if (isEmpty(data)) {
@@ -29,6 +30,10 @@ function normalizeStateCounts(data) {
 }
 
 export default class FleetApplication extends SteveModel {
+  get applicationType() {
+    return this.kind;
+  }
+
   async getCurrentUser() {
     const user = this.$rootGetters['auth/user'];
 
@@ -138,7 +143,8 @@ export default class FleetApplication extends SteveModel {
   }
 
   get targetInfo() {
-    const mode = FleetUtils.Application.getTargetMode(this.spec.targets || [], this.metadata.namespace);
+    const areHarvesterHostsVisible = this.$rootGetters['features/get'](HARVESTER_CONTAINER);
+    const mode = FleetUtils.Application.getTargetMode(this.spec.targets || [], this.metadata.namespace, areHarvesterHostsVisible);
 
     return {
       mode,

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

@@ -4,10 +4,29 @@ import { set } from '@shell/utils/object';
 import { SOURCE_TYPE } from '@shell/config/product/fleet';
 import FleetUtils from '@shell/utils/fleet';
 import { FLEET } from '@shell/config/types';
-import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
+import { CATALOG, FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
 import FleetApplication from '@shell/models/fleet-application';
+import { SUSE_APP_COLLECTION_REPO_URL, SUSE_APPCO_DISPLAY_NAME } from '@shell/utils/fleet-appco';
 
 export default class HelmOp extends FleetApplication {
+  get isSuseAppCollectionFromUI() {
+    return !!this.metadata?.annotations?.[CATALOG.SUSE_APP_COLLECTION];
+  }
+
+  get isSuseAppCollection() {
+    // Annotation set by the UI on create, or fallback to URL check for older resources
+    return this.isSuseAppCollectionFromUI ||
+      (this.spec?.helm?.repo || '').startsWith(SUSE_APP_COLLECTION_REPO_URL);
+  }
+
+  get applicationType() {
+    if (this.isSuseAppCollectionFromUI) {
+      return SUSE_APPCO_DISPLAY_NAME;
+    }
+
+    return this.kind;
+  }
+
   applyDefaults() {
     const spec = this.spec || {};
     const meta = this.metadata || {};