@rancher/shell 0.3.4 → 0.3.6

package/mixins/chart.js

@@ -14,6 +14,8 @@ import { CAPI, CATALOG } from '@shell/config/types';
 import { isPrerelease } from '@shell/utils/version';
 import difference from 'lodash/difference';
 import { LINUX } from '@shell/store/catalog';
+import { clone } from 'utils/object';
+import { merge } from 'lodash';
 
 export default {
   data() {
@@ -292,7 +294,13 @@ export default {
       // use the first version provided by the Helm chart
       // as the default.
       if ( !this.query.versionName && this.chart.versions?.length ) {
-        this.query.versionName = this.chart.versions[0].version;
+        if (this.showPreRelease) {
+          this.query.versionName = this.chart.versions[0].version;
+        } else {
+          const firstRelease = this.chart.versions.find(v => !isPrerelease(v.version));
+
+          this.query.versionName = firstRelease?.version || this.chart.versions[0].version;
+        }
       }
 
       if ( !this.query.versionName ) {
@@ -341,6 +349,97 @@ export default {
       }
     }, // End of fetchChart
 
+    // Charts have an annotation that specifies any additional charts that should be installed at the same time eg CRDs
+    async fetchAutoInstallInfo() {
+      const out = [];
+      /*
+        An example value for auto is ["rancher-monitoring-crd=match"].
+        It is an array of chart names that lets Rancher know of other
+        charts that should be auto-installed at the same time.
+      */
+      const auto = (this.version?.annotations?.[CATALOG_ANNOTATIONS.AUTO_INSTALL] || '').split(/\s*,\s*/).filter(x => !!x).reverse();
+
+      for ( const constraint of auto ) {
+        const provider = this.$store.getters['catalog/versionSatisfying']({
+          constraint,
+          repoName:     this.chart.repoName,
+          repoType:     this.chart.repoType,
+          chartVersion: this.version.version,
+        });
+        /* An example return value for "provider":
+          [
+              {
+                  "name": "rancher-monitoring-crd",
+                  "version": "100.1.3+up19.0.3",
+                  "description": "Installs the CRDs for rancher-monitoring.",
+                  "apiVersion": "v1",
+                  "annotations": {
+                      "catalog.cattle.io/certified": "rancher",
+                      "catalog.cattle.io/hidden": "true",
+                      "catalog.cattle.io/namespace": "cattle-monitoring-system",
+                      "catalog.cattle.io/release-name": "rancher-monitoring-crd"
+                  },
+                  "type": "application",
+                  "urls": [
+                      "https://192.168.0.18:8005/k8s/clusters/c-m-hhpg69fv/v1/catalog.cattle.io.clusterrepos/rancher-charts?chartName=rancher-monitoring-crd&link=chart&version=100.1.3%2Bup19.0.3"
+                  ],
+                  "created": "2022-04-27T10:04:18.343124-07:00",
+                  "digest": "ecf07ba23a9cdaa7ffbbb14345d94ea1240b7f3b8e0ce9be4640e3e585c484e2",
+                  "key": "cluster/rancher-charts/rancher-monitoring-crd/100.1.3+up19.0.3",
+                  "repoType": "cluster",
+                  "repoName": "rancher-charts"
+              }
+          ]
+          */
+
+        if ( provider ) {
+          try {
+            const crdVersionInfo = await this.$store.dispatch('catalog/getVersionInfo', {
+              repoType:    provider.repoType,
+              repoName:    provider.repoName,
+              chartName:   provider.name,
+              versionName: provider.version
+            });
+            let existingCRDApp;
+
+            // search for an existing crd app to track any non-default values used on the previous install/upgrade
+            if (this.mode === _EDIT) {
+              const targetNamespace = crdVersionInfo?.chart?.annotations?.[CATALOG_ANNOTATIONS.NAMESPACE];
+              const targetName = crdVersionInfo?.chart?.annotations?.[CATALOG_ANNOTATIONS.RELEASE_NAME];
+
+              if (targetName && targetNamespace) {
+                existingCRDApp = await this.$store.dispatch('cluster/find', {
+                  type: CATALOG.APP,
+                  id:   `${ targetNamespace }/${ targetName }`,
+                });
+              }
+            }
+            if (existingCRDApp) {
+              // spec.values are any non-default values the user configured
+              // the installation form should show these, as well as any default values from the chart
+              const existingValues = clone(existingCRDApp.spec?.values || {});
+              const defaultValues = clone(existingCRDApp.spec?.chart?.values || {});
+
+              crdVersionInfo.existingValues = existingValues;
+              crdVersionInfo.allValues = merge(defaultValues, existingValues);
+            } else {
+              // allValues will potentially be updated in the UI - we want to track this separately from values to avoid mutating the chart object in the store
+              // this is similar to userValues for the main chart
+              crdVersionInfo.allValues = clone(crdVersionInfo.values);
+            }
+
+            out.push(crdVersionInfo);
+          } catch (e) {
+            console.error('Unable to fetch VersionInfo: ', e); // eslint-disable-line no-console
+          }
+        } else {
+          this.errors.push(`This chart requires ${ constraint } but no matching chart was found`);
+        }
+      }
+
+      this.$set(this, 'autoInstallInfo', out);
+    },
+
     selectVersion({ id: version }) {
       this.$router.applyQuery({ [VERSION]: version });
     },
@@ -361,7 +460,7 @@ export default {
         repoType: this.chart.repoType,
         repoName: this.chart.repoName,
         name:     this.chart.chartName,
-        version:  this.chart.versionName,
+        version:  this.query.versionName,
       };
 
       return {

package/mixins/fetch.client.js

@@ -0,0 +1,95 @@
+import Vue from 'vue';
+import { hasFetch, normalizeError, addLifecycleHook } from '../utils/nuxt';
+
+const isSsrHydration = vm => vm.$vnode && vm.$vnode.elm && vm.$vnode.elm.dataset && vm.$vnode.elm.dataset.fetchKey;
+const nuxtState = window.__NUXT__;
+
+export default {
+  beforeCreate() {
+    if (!hasFetch(this)) {
+      return;
+    }
+
+    this._fetchDelay = typeof this.$options.fetchDelay === 'number' ? this.$options.fetchDelay : 200;
+
+    Vue.util.defineReactive(this, '$fetchState', {
+      pending:   false,
+      error:     null,
+      timestamp: Date.now()
+    });
+
+    this.$fetch = $fetch.bind(this);
+    addLifecycleHook(this, 'created', created);
+    addLifecycleHook(this, 'beforeMount', beforeMount);
+  }
+};
+
+function beforeMount() {
+  if (!this._hydrated) {
+    return this.$fetch();
+  }
+}
+
+function created() {
+  if (!isSsrHydration(this)) {
+    return;
+  }
+
+  // Hydrate component
+  this._hydrated = true;
+  this._fetchKey = this.$vnode.elm.dataset.fetchKey;
+  const data = nuxtState.fetch[this._fetchKey];
+
+  // If fetch error
+  if (data && data._error) {
+    this.$fetchState.error = data._error;
+
+    return;
+  }
+
+  // Merge data
+  for (const key in data) {
+    Vue.set(this.$data, key, data[key]);
+  }
+}
+
+function $fetch() {
+  if (!this._fetchPromise) {
+    this._fetchPromise = $_fetch.call(this)
+      .then(() => {
+        delete this._fetchPromise;
+      });
+  }
+
+  return this._fetchPromise;
+}
+
+async function $_fetch() { // eslint-disable-line camelcase
+  this.$nuxt.nbFetching++;
+  this.$fetchState.pending = true;
+  this.$fetchState.error = null;
+  this._hydrated = false;
+  let error = null;
+  const startTime = Date.now();
+
+  try {
+    await this.$options.fetch.call(this);
+  } catch (err) {
+    if (process.dev) {
+      console.error('Error in fetch():', err); // eslint-disable-line no-console
+    }
+    error = normalizeError(err);
+  }
+
+  const delayLeft = this._fetchDelay - (Date.now() - startTime);
+
+  if (delayLeft > 0) {
+    await new Promise(resolve => setTimeout(resolve, delayLeft));
+  }
+
+  this.$fetchState.error = error;
+  this.$fetchState.pending = false;
+  this.$fetchState.timestamp = Date.now();
+
+  this.$nextTick(() => this.$nuxt.nbFetching--);
+}

package/mixins/fetch.server.js

@@ -0,0 +1,73 @@
+import Vue from 'vue';
+import {
+  hasFetch, normalizeError, addLifecycleHook, purifyData, createGetCounter
+} from '../../utils/nuxt';
+
+async function serverPrefetch() {
+  if (!this._fetchOnServer) {
+    return;
+  }
+
+  // Call and await on $fetch
+  try {
+    await this.$options.fetch.call(this);
+  } catch (err) {
+    if (process.dev) {
+      console.error('Error in fetch():', err); // eslint-disable-line no-console
+    }
+    this.$fetchState.error = normalizeError(err);
+  }
+  this.$fetchState.pending = false;
+
+  // Define an ssrKey for hydration
+  this._fetchKey = this._fetchKey || this.$ssrContext.fetchCounters['']++;
+
+  // Add data-fetch-key on parent element of Component
+  const attrs = this.$vnode.data.attrs = this.$vnode.data.attrs || {};
+
+  attrs['data-fetch-key'] = this._fetchKey;
+
+  // Add to ssrContext for window.__NUXT__.fetch
+
+  if (this.$ssrContext.nuxt.fetch[this._fetchKey] !== undefined) {
+    console.warn(`Duplicate fetch key detected (${ this._fetchKey }). This may lead to unexpected results.`); // eslint-disable-line no-console
+  }
+
+  this.$ssrContext.nuxt.fetch[this._fetchKey] =
+    this.$fetchState.error ? { _error: this.$fetchState.error } : purifyData(this._data);
+}
+
+export default {
+  created() {
+    if (!hasFetch(this)) {
+      return;
+    }
+
+    if (typeof this.$options.fetchOnServer === 'function') {
+      this._fetchOnServer = this.$options.fetchOnServer.call(this) !== false;
+    } else {
+      this._fetchOnServer = this.$options.fetchOnServer !== false;
+    }
+
+    const defaultKey = this.$options._scopeId || this.$options.name || '';
+    const getCounter = createGetCounter(this.$ssrContext.fetchCounters, defaultKey);
+
+    if (typeof this.$options.fetchKey === 'function') {
+      this._fetchKey = this.$options.fetchKey.call(this, getCounter);
+    } else {
+      const key = typeof this.$options.fetchKey === 'string' ? this.$options.fetchKey : defaultKey;
+
+      this._fetchKey = key ? `${ key }:${ getCounter(key) }` : String(getCounter(key));
+    }
+
+    // Added for remove vue undefined warning while ssr
+    this.$fetch = () => {}; // issue #8043
+    Vue.util.defineReactive(this, '$fetchState', {
+      pending:   true,
+      error:     null,
+      timestamp: Date.now()
+    });
+
+    addLifecycleHook(this, 'serverPrefetch', serverPrefetch);
+  }
+};

package/mixins/labeled-form-element.ts

@@ -122,7 +122,7 @@ export default Vue.extend({
     },
     validationMessage(): string | undefined {
       // we want to grab the required rule passed in if we can but if it's not there then we can just grab it from the formRulesGenerator
-      const requiredRule = this.rules.find((rule: any) => rule?.name === 'required');
+      const requiredRule = this.rules.find((rule: any) => rule?.name === 'required') as Function;
       const ruleMessages = [];
       const value = this?.value;
 
@@ -134,7 +134,7 @@ export default Vue.extend({
         }
       }
 
-      for (const rule of this.rules) {
+      for (const rule of this.rules as Function[]) {
         const message = rule(value);
 
         if (!!message && rule.name !== 'required') { // we're catching 'required' above so we can ignore it here

package/mixins/resource-fetch.js

@@ -131,8 +131,8 @@ export default {
 
       const schema = this.$store.getters[`${ currStore }/schemaFor`](type);
 
-      if (schema?.attributes?.namespaced) {
-        opt.namespaced = this.namespaceFilter;
+      if (schema?.attributes?.namespaced) { // Is this specific resource namespaced (could be primary or secondary resource)?
+        opt.namespaced = this.namespaceFilter; // namespaceFilter will only be populated if applicable for primary resource
       }
 
       return this.$store.dispatch(`${ currStore }/findAll`, {

package/models/apps.statefulset.js

@@ -1,4 +1,6 @@
 import Workload from './workload';
+import { WORKLOAD_TYPES, POD } from '@shell/config/types';
+import { WORKLOAD_TYPE_TO_KIND_MAPPING } from '@shell/detail/workload/index';
 
 export default class StatefulSet extends Workload {
   async rollBack(cluster, statefulSet, revision) {
@@ -19,4 +21,30 @@ export default class StatefulSet extends Workload {
 
     await this.rollBackWorkload(cluster, statefulSet, 'statefulsets', body);
   }
+
+  // we need to provide a new pods getter for statefulsets because the relationship
+  // done on the parent model "workload" is not correct
+  get pods() {
+    const relationships = this.metadata?.relationships || [];
+    const podRelationship = relationships.filter(relationship => relationship.toType === POD)[0];
+
+    if (podRelationship) {
+      const pods = this.$getters['podsByNamespace'](this.metadata.namespace);
+
+      return pods.filter((pod) => {
+        // a bit of a duplication of podRelationship, but always safe to check...
+        if (pod.metadata?.ownerReferences?.length) {
+          const ownerReferencesStatefulSet = pod.metadata?.ownerReferences?.find(own => own.kind === WORKLOAD_TYPE_TO_KIND_MAPPING[WORKLOAD_TYPES.STATEFUL_SET]);
+
+          if (ownerReferencesStatefulSet) {
+            return `${ pod.metadata.namespace }/${ ownerReferencesStatefulSet.name }` === this.id;
+          }
+        }
+
+        return false;
+      });
+    }
+
+    return [];
+  }
 }

package/models/cluster/node.js

@@ -1,5 +1,5 @@
 import { formatPercent } from '@shell/utils/string';
-import { CAPI as CAPI_ANNOTATIONS, NODE_ROLES, RKE } from '@shell/config/labels-annotations.js';
+import { CAPI as CAPI_ANNOTATIONS, NODE_ROLES, RKE, SYSTEM_LABELS } from '@shell/config/labels-annotations.js';
 import {
   CAPI, MANAGEMENT, METRIC, NORMAN, POD
 } from '@shell/config/types';
@@ -76,7 +76,8 @@ export default class ClusterNode extends SteveModel {
   }
 
   openSsh() {
-    this.provisionedMachine.openSsh();
+    // Pass in the name of the node, so we display that rather than the name of the provisioned machine
+    this.provisionedMachine.openSsh(this.nameDisplay);
   }
 
   downloadKeys() {
@@ -109,6 +110,26 @@ export default class ClusterNode extends SteveModel {
     return this.metadata?.labels || {};
   }
 
+  get customLabelCount() {
+    return this.customLabels.length;
+  }
+
+  get customLabels() {
+    const parsedLabels = [];
+
+    if (this.labels) {
+      for (const k in this.labels) {
+        const [prefix] = k.split('/');
+
+        if (!SYSTEM_LABELS.includes(prefix)) {
+          parsedLabels.push(`${ k }=${ this.labels[k] }`);
+        }
+      }
+    }
+
+    return parsedLabels;
+  }
+
   get isWorker() {
     return this.managementNode ? this.managementNode.isWorker : `${ this.labels[NODE_ROLES.WORKER] }` === 'true';
   }

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

@@ -98,10 +98,12 @@ export default class CapiMachine extends SteveModel {
     return false;
   }
 
-  openSsh() {
+  openSsh(name) {
+    const label = name || this.nameDisplay;
+
     this.$dispatch('wm/open', {
       id:        `${ this.id }-ssh`,
-      label:     this.nameDisplay,
+      label,
       icon:      'terminal',
       component: 'MachineSsh',
       attrs:     { machine: this, pod: {} }

package/models/clusterroletemplatebinding.js

@@ -21,4 +21,11 @@ export default class CRTB extends NormanModel {
   get clusterroletemplatebinding() {
     return this.$rootGetters[`management/byId`](MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING, this.id?.replace(':', '/'));
   }
+
+  get steve() {
+    return this.$dispatch(`management/find`, {
+      type: MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING,
+      id:   this.id?.replace(':', '/')
+    }, { root: true });
+  }
 }

package/models/constraints.gatekeeper.sh.constraint.js

@@ -1,5 +1,6 @@
 import jsyaml from 'js-yaml';
 import SteveModel from '@shell/plugins/steve/steve-class';
+import { downloadFile } from '@shell/utils/download';
 
 export const ENFORCEMENT_ACTION_VALUES = {
   DENY:   'deny',
@@ -7,21 +8,62 @@ export const ENFORCEMENT_ACTION_VALUES = {
 };
 
 export default class GateKeeperConstraint extends SteveModel {
+  get _availableActions() {
+    const out = super._availableActions;
+
+    const t = this.$rootGetters['i18n/t'];
+
+    const downloadViolations = {
+      action: 'downloadViolations',
+      icon:   'icon icon-fw icon-download',
+      label:  t('gatekeeperConstraint.downloadViolations'),
+      total:  1,
+    };
+
+    out.unshift(downloadViolations);
+
+    return out;
+  }
+
   async save() {
     let constraint;
+    let resourceVersion;
 
     if (this.constraint) {
       constraint = await this.findLatestConstraint();
+      resourceVersion = constraint?.metadata?.resourceVersion;
     } else {
       constraint = await this.$dispatch('cluster/create', { type: `constraints.gatekeeper.sh.${ this.kind.toLowerCase() }` }, { root: true });
     }
 
     constraint.spec = this.spec;
     constraint.metadata = this.metadata;
+    if (resourceVersion) {
+      constraint.metadata.resourceVersion = resourceVersion;
+    }
 
     await constraint.save();
   }
 
+  async downloadViolations() {
+    const Papa = await import(/* webpackChunkName: "csv" */'papaparse');
+
+    try {
+      const violations = (this.violations || []).map((violation) => {
+        delete violation.resourceLink;
+        delete violation.constraintLink;
+
+        return violation;
+      });
+
+      const csv = Papa.unparse(violations);
+
+      downloadFile(`violations-${ this.name }.csv`, csv, 'application/csv');
+    } catch (err) {
+      this.$dispatch('growl/fromError', { title: 'Error downloading file', err }, { root: true });
+    }
+  }
+
   cleanForNew() {
     this.$dispatch(`cleanForNew`, this);
 
@@ -50,6 +92,10 @@ export default class GateKeeperConstraint extends SteveModel {
     }, { root: true });
   }
 
+  get totalViolations() {
+    return this.status?.totalViolations || this.violations.length;
+  }
+
   get violations() {
     const violations = this.status?.violations || [];
 

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

@@ -1,8 +1,9 @@
 import { MANAGEMENT, NORMAN } from '@shell/config/types';
+import { CAPI, FLEET as FLEET_LABELS } from '@shell/config/labels-annotations';
+import { _RKE2 } from '@shell/store/prefs';
+import SteveModel from '@shell/plugins/steve/steve-class';
 import { escapeHtml } from '@shell/utils/string';
 import { insertAt } from '@shell/utils/array';
-import { FLEET as FLEET_LABELS } from '@shell/config/labels-annotations';
-import SteveModel from '@shell/plugins/steve/steve-class';
 
 export default class FleetCluster extends SteveModel {
   get _availableActions() {
@@ -32,14 +33,16 @@ export default class FleetCluster extends SteveModel {
       enabled:  !!this.links.update
     });
 
-    insertAt(out, 3, {
-      action:     'assignTo',
-      label:      'Change workspace',
-      icon:       'icon icon-copy',
-      bulkable:   true,
-      bulkAction: 'assignToBulk',
-      enabled:    !!this.links.update && !!this.mgmt,
-    });
+    if (!this.isRke2) {
+      insertAt(out, 3, {
+        action:     'assignTo',
+        label:      'Change workspace',
+        icon:       'icon icon-copy',
+        bulkable:   true,
+        bulkAction: 'assignToBulk',
+        enabled:    !!this.links.update && !!this.mgmt,
+      });
+    }
 
     insertAt(out, 4, { divider: true });
 
@@ -75,6 +78,12 @@ export default class FleetCluster extends SteveModel {
     return false;
   }
 
+  get isRke2() {
+    const provider = this?.metadata?.labels?.[CAPI.PROVIDER] || this?.status?.provider;
+
+    return provider === _RKE2;
+  }
+
   get nameDisplay() {
     return this.metadata?.labels?.[FLEET_LABELS.CLUSTER_DISPLAY_NAME] || this.metadata?.name || this.id;
   }

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

@@ -96,9 +96,8 @@ export default class GitRepo extends SteveModel {
     const workspace = this.$getters['byId'](FLEET.WORKSPACE, this.metadata.namespace);
     const clusters = workspace?.clusters || [];
     const groups = workspace?.clusterGroups || [];
-    const out = [];
 
-    if ( workspace.id === 'fleet-local' ) {
+    if ( workspace?.id === 'fleet-local' ) {
       const local = findBy(groups, 'id', 'fleet-local/default');
 
       if ( local ) {
@@ -108,6 +107,12 @@ export default class GitRepo extends SteveModel {
       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);

package/models/management.cattle.io.cluster.js

@@ -196,7 +196,7 @@ export default class MgmtCluster extends HybridModel {
   }
 
   get kubernetesVersionExtension() {
-    if ( this.kubernetesVersion.match(/[+-]]/) ) {
+    if ( this.kubernetesVersion.match(/[+-]/) ) {
       return this.kubernetesVersion.replace(/^.*([+-])/, '$1');
     }
 

package/models/management.cattle.io.fleetworkspace.js

@@ -66,6 +66,18 @@ export default class Workspace extends HybridModel {
     await norman.save();
   }
 
+  waitForWorkspaceSchema(timeout = 20000, schemaCallback) {
+    return this.waitForTestFn(() => {
+      const schema = this.$rootGetters['management/schemaFor'](FLEET.WORKSPACE);
+
+      if (!schemaCallback) {
+        return schema;
+      }
+
+      return schemaCallback(schema);
+    }, this.$rootGetters['i18n/t']('fleet.workspaces.timeout'), timeout);
+  }
+
   async remove() {
     const norman = await this.norman;
 

package/models/management.cattle.io.gitreporestriction.js

@@ -0,0 +1,5 @@
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class GitRepoRestriction extends SteveModel {
+
+}

package/models/management.cattle.io.podsecurityadmissionconfigurationtemplate.js

@@ -0,0 +1,3 @@
+import SteveDescriptionModel from '@shell/plugins/steve/steve-description-class';
+
+export default class PodSecurityAdmissionTemplate extends SteveDescriptionModel { }

package/models/pod.js

@@ -129,6 +129,10 @@ export default class Pod extends WorkloadService {
     return workloads[0];
   }
 
+  get ownedByWorkload() {
+    return !!this.workloadRef;
+  }
+
   get details() {
     const out = [
       {