@rancher/shell 3.0.12-rc.1 → 3.0.12-rc.3

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

@@ -1,22 +1,25 @@
-import { CATALOG, CLUSTER_BADGE } from '@shell/config/labels-annotations';
+import { CATALOG, CLUSTER_BADGE, NODE_ARCHITECTURE } from '@shell/config/labels-annotations';
 import {
-  NODE, FLEET, MANAGEMENT, CAPI, EXT
+  NODE, FLEET, MANAGEMENT, CAPI, EXT,
+  NORMAN,
+  HCI
 } from '@shell/config/types';
 import { insertAt, addObject, removeObject } from '@shell/utils/array';
 import { downloadFile } from '@shell/utils/download';
 import { parseSi } from '@shell/utils/units';
 import { parseColor, textColor } from '@shell/utils/color';
-import { addParams } from '@shell/utils/url';
-import { isEmpty } from '@shell/utils/object';
+import { isEmpty, isEqual } from '@shell/utils/object';
 import { HARVESTER_NAME as HARVESTER } from '@shell/config/features';
 import { isHarvesterCluster } from '@shell/utils/cluster';
 import SteveModel from '@shell/plugins/steve/steve-class';
 import { LINUX, WINDOWS } from '@shell/store/catalog';
-import { KONTAINER_TO_DRIVER } from './management.cattle.io.kontainerdriver';
+import { KEV1 } from './management.cattle.io.kontainerdriver';
 import { requireAsset } from '@shell/utils/require-asset';
 import { PINNED_CLUSTERS } from '@shell/store/prefs';
 import { copyTextToClipboard } from '@shell/utils/clipboard';
 import { isHostedProvider } from '@shell/utils/provider';
+import { ucFirst } from '@shell/utils/string';
+import { sortBy } from '@shell/utils/sort';
 
 const DEFAULT_BADGE_COLOR = '#707070';
 
@@ -57,6 +60,30 @@ export default class MgmtCluster extends SteveModel {
     return (schema?.collectionMethods || []).includes('POST');
   }
 
+  get availableActions() {
+    // If on the Cluster Management Cluster List use the provisioning cluster actions instead of the management cluster
+    // This resolution feels a bit hacky, however the alternative would be to create a table prop and lots of weird plumbing
+    // It's a small use case, so just doing a limited solution
+    const listLocation = this.provCluster?.listLocation || {};
+    const currentRoute = this.currentRoute();
+
+    // Compare params, but exclude cluster (could be a bad link which provides a specific cluster)
+    const { cluster: _1, ...lLProduct } = listLocation.params || {};
+    const { cluster: _2, ...cRParams } = currentRoute.params;
+    const paramsEqual = isEqual(lLProduct, cRParams);
+
+    const isClusterManagementListPage = listLocation?.name === currentRoute?.name && paramsEqual;
+
+    if (isClusterManagementListPage) {
+      return this.provCluster?.availableActions.map((action) => ({
+        ...action,
+        altResource: this.provCluster, // actions work by using the row's resource with the function name. this overrides that
+      }));
+    }
+
+    return super.availableActions;
+  }
+
   get _availableActions() {
     const out = super._availableActions;
 
@@ -98,75 +125,171 @@ export default class MgmtCluster extends SteveModel {
   }
 
   get provisioner() {
+    // Sometimes the driver will be empty (like unconnected custom rke2 clusters), so fall back on the new and improved status.provider
+    if (this.status?.provider) {
+      if (['gke', 'eks', 'aks', 'k3s'].includes(this.status.provider)) {
+        // Defensive coding. we're now using status.provider which uses lowercase for some distro's
+        // To support the old use case of upper case status.driver values make status.provider upper case...
+        return this.status.provider.toUpperCase();
+      }
+
+      return this.status.provider;
+    }
+
     // For imported K3s clusters, this.status.driver is 'k3s.'
-    return this.status?.driver ? this.status.driver : 'imported';
+    if (this.status?.driver) {
+      return this.status.driver;
+    }
+
+    return 'imported';
   }
 
-  get machineProvider() {
-    const kind = this.machinePools?.[0]?.provider;
+  get provisionerDisplay() {
+    // Allow a model extension to override the display of the provisioner
+    if (this.customProvisionerHelper?.provisionerDisplay) {
+      return this.customProvisionerHelper?.provisionerDisplay(this);
+    }
+
+    let provisioner = this.provisioner?.toLowerCase();
 
-    if ( kind ) {
-      return kind.replace(/config$/i, '').toLowerCase();
-    } else if ( this.spec?.internal ) {
-      return 'local';
+    if (provisioner === 'rke.windows') {
+      provisioner = 'rkeWindows';
     }
 
-    return null;
+    if (!this.$rootGetters['i18n/exists'](`cluster.provider.${ provisioner }`)) {
+      provisioner = 'other';
+    }
+
+    return this.$rootGetters['i18n/withFallback'](`cluster.provider."${ provisioner }"`, null, ucFirst(this.provisioner));
   }
 
-  get providerForEmberParam() {
-    // Ember wants one word called provider to tell what component to show, but has much indirect mapping to figure out what it is.
-    let provider;
+  /**
+   * Get the custom provisioner helper for this model
+   */
+  get customProvisionerHelper() {
+    if (!this.provCluster) {
+      return null;
+    }
 
-    //  provisioner is status.driver
-    const provisioner = KONTAINER_TO_DRIVER[(this.provisioner || '').toLowerCase()] || this.provisioner;
+    // Find the first model extension that says it can be used for this model
+    return this.modelExtensions.find((modelExt) => modelExt.useFor ? modelExt.useFor(this.provCluster) : false);
+  }
 
-    if ( provisioner === 'rancherKubernetesEngine') {
-      // Look for a cloud provider in one of the node templates
-      if ( this.machinePools?.[0] ) {
-        provider = this.machinePools[0]?.nodeTemplate?.spec?.driver || null;
-      } else {
-        provider = 'custom';
-      }
-    } else if ( this.driver ) {
-      provider = this.driver;
-    } else if ( provisioner && provisioner.endsWith('v2') ) {
-      provider = provisioner;
+  get provider() {
+    return this.status?.provider;
+  }
+
+  get machineProvider() {
+    return this.status?.info.machineProvider;
+  }
+
+  get machineProviderDisplay() {
+    if (this.customProvisionerHelper?.machineProviderDisplay) {
+      return this.customProvisionerHelper?.machineProviderDisplay(this);
+    }
+
+    const provider = (this.machineProvider || '').toLowerCase();
+
+    if ( provider ) {
+      return this.$rootGetters['i18n/withFallback'](`cluster.provider."${ provider }"`, null, provider);
     } else {
-      provider = 'import';
+      return this.$rootGetters['i18n/t']('generic.unknown');
     }
+  }
 
-    return provider;
+  // Is the cluster a legacy (unsupported) KEV1 cluster?
+  get isKev1() {
+    return KEV1.includes(this.spec?.genericEngineConfig?.driverName);
   }
 
-  get emberEditPath() {
-    const provider = this.providerForEmberParam;
+  get isImported() {
+    const provider = this.status?.provider;
+    const driver = this.status?.driver;
 
-    // Avoid passing falsy values as query parameters
-    const qp = { };
+    // The main case
+    if (provider === 'k3s' || provider === 'rke2') {
+      return driver === provider;
+    }
+    // The 'waiting' case
+    if (!provider && (driver === 'k3s' || driver === 'rke2')) {
+      return true;
+    }
 
-    if (provider) {
-      qp['provider'] = provider;
+    // imported KEv2
+    // we can't rely on this.provisioner to determine imported-ness for these clusters, as it will return 'aks' 'eks' 'gke' for both provisioned and imported clusters
+    if (this.isHostedKubernetesProvider && !!this.provCluster?.providerConfig?.imported) {
+      return true;
     }
 
-    // Copied out of https://github.com/rancher/ui/blob/20f56dc54c4fc09b5f911e533cb751c13609adaf/app/models/cluster.js#L844
-    if ( provider === 'import' && isEmpty(this.eksConfig) && isEmpty(this.gkeConfig) ) {
-      qp.importProvider = 'other';
-    } else if (
-      (provider === 'amazoneks' && !isEmpty(this.eksConfig) ) ||
-       (provider === 'gke' && !isEmpty(this.gkeConfig) )
-       // || something for aks v2
-    ) {
-      qp.importProvider = KONTAINER_TO_DRIVER[provider];
+    return this.provisioner === 'imported';
+  }
+
+  get isCustom() {
+    if ( this.isRke2 ) {
+      return !(this.provCluster?.spec?.rkeConfig?.machinePools?.length);
     }
 
-    const path = addParams(`/c/${ escape(this.id) }/edit`, qp);
+    return false;
+  }
+
+  get isImportedK3s() {
+    return this.isImported && this.isK3s;
+  }
 
-    return path;
+  get isImportedRke2() {
+    return this.isImported && this.provider?.startsWith('rke2');
+  }
+
+  get isK3s() {
+    return this.status ? this.status.provider === 'k3s' : (this.kubernetesVersion || '').includes('k3s') ;
+  }
+
+  get isRke2() {
+    return !!this.provCluster?.isRke2;
+  }
+
+  // identify v2 provisioning clusters created using upstream capi infrastructure providers instead of rancher/machine
+  get isCapiHybrid() {
+    if (!this.isRke2) {
+      return false;
+    }
+
+    const machineReferences = (this.provCluster.spec?.rkeConfig?.machinePools || []).map((pool) => pool.machineConfigRef);
+
+    const capiMachines = machineReferences.find((r) => r?.apiVersion?.includes('cluster.x-k8s.io'));
+
+    return !!capiMachines;
+  }
+
+  get isHostedKubernetesProvider() {
+    const context = {
+      dispatch:   this.$dispatch,
+      getters:    this.$getters,
+      axios:      this.$axios,
+      $extension: this.$extension,
+      t:          (...args) => this.t.apply(this, args),
+    };
+
+    return isHostedProvider(context, this.provisioner);
+  }
+
+  get isPrivateHostedProvider() {
+    if (this.isHostedKubernetesProvider && this.provisioner) {
+      switch (this.provisioner.toLowerCase()) {
+      case 'gke':
+        return this.spec?.gkeConfig?.privateClusterConfig?.enablePrivateEndpoint;
+      case 'eks':
+        return this.spec?.eksConfig?.privateAccess;
+      case 'aks':
+        return this.spec?.aksConfig?.privateCluster;
+      }
+    }
+
+    return false;
   }
 
   get groupByLabel() {
-    return this.$rootGetters['i18n/t']('resourceTable.groupLabel.notInAWorkspace');
+    return `Workspace: ${ this.spec.fleetWorkspaceName }`;
   }
 
   get isReady() {
@@ -191,10 +314,7 @@ export default class MgmtCluster extends SteveModel {
   }
 
   get kubernetesVersionRaw() {
-    const fromStatus = this.status?.version?.gitVersion;
-    const fromSpec = this.config?.kubernetesVersion;
-
-    return fromStatus || fromSpec;
+    return this.statusInfo.kubernetesVersion;
   }
 
   get kubernetesVersion() {
@@ -214,7 +334,7 @@ export default class MgmtCluster extends SteveModel {
   }
 
   get providerOs() {
-    if ( this.status?.provider.endsWith('.windows')) {
+    if ( this.provider?.endsWith('.windows')) {
       return 'windows';
     }
 
@@ -257,20 +377,8 @@ export default class MgmtCluster extends SteveModel {
     return isHarvesterCluster(this);
   }
 
-  get isHostedKubernetesProvider() {
-    const context = {
-      dispatch:   this.$dispatch,
-      getters:    this.$getters,
-      axios:      this.$axios,
-      $extension: this.$extension,
-      t:          (...args) => this.t.apply(this, args),
-    };
-
-    return isHostedProvider(context, this.provisioner);
-  }
-
   get providerLogo() {
-    let provider = this.status?.provider || 'kubernetes';
+    let provider = this.provider || 'kubernetes';
 
     if (this.isHarvester) {
       provider = HARVESTER;
@@ -301,6 +409,136 @@ export default class MgmtCluster extends SteveModel {
     return this.providerLogo;
   }
 
+  get pools() {
+    const deployments = this.$rootGetters['management/all'](CAPI.MACHINE_DEPLOYMENT).filter((pool) => pool.spec?.clusterName === this.provClusterName);
+
+    if (!!deployments.length) {
+      return deployments;
+    }
+
+    return this.machinePools;
+  }
+
+  get desired() {
+    return this.pools.reduce((acc, pool) => acc + (pool.desired || 0), 0);
+  }
+
+  get pending() {
+    return this.pools.reduce((acc, pool) => acc + (pool.pending || 0), 0);
+  }
+
+  get outdated() {
+    return this.pools.reduce((acc, pool) => acc + (pool.outdated || 0), 0);
+  }
+
+  get ready() {
+    return this.pools.reduce((acc, pool) => acc + (pool.ready || 0), 0);
+  }
+
+  get stateParts() {
+    const out = [
+      {
+        label:     'Pending',
+        color:     'bg-info',
+        textColor: 'text-info',
+        value:     this.pending,
+        sort:      1,
+      },
+      {
+        label:     'Outdated',
+        color:     'bg-warning',
+        textColor: 'text-warning',
+        value:     this.outdated,
+        sort:      2,
+      },
+      {
+        label:     'Unavailable',
+        color:     'bg-error',
+        textColor: 'text-error',
+        value:     this.unavailable,
+        sort:      3,
+      },
+      {
+        label:     'Ready',
+        color:     'bg-success',
+        textColor: 'text-success',
+        value:     this.ready,
+        sort:      4,
+      },
+    ].filter((x) => x.value > 0);
+
+    return sortBy(out, 'sort:desc');
+  }
+
+  get nodes() {
+    return this.$getters['all'](MANAGEMENT.NODE).filter((node) => node.id.startsWith(this.id));
+  }
+
+  get nodesArchitecture() {
+    const obj = {};
+
+    this.nodes?.forEach((node) => {
+      if (!node.metadata?.state?.transitioning) {
+        const architecture = node.status?.nodeLabels?.[NODE_ARCHITECTURE];
+
+        const key = architecture || this.t('cluster.architecture.label.unknown');
+
+        obj[key] = (obj[key] || 0) + 1;
+      }
+    });
+
+    return obj;
+  }
+
+  get architecture() {
+    if (!this.statusInfo.arch) {
+      return { label: this.t('generic.provisioning') };
+    }
+    if (this.statusInfo.arch === 'mixed') {
+      return { label: this.t('cluster.architecture.label.mixed') };
+    }
+
+    return { label: this.statusInfo.arch };
+  }
+
+  get machines() {
+    return this.$rootGetters['management/all'](CAPI.MACHINE).filter((machine) => {
+      if ( machine.metadata?.namespace !== this.provClusterNamespace ) {
+        return false;
+      }
+
+      return machine.spec?.clusterName === this.provClusterName;
+    });
+  }
+
+  get unavailable() {
+    return this.pools.reduce((acc, pool) => acc + (pool.unavailable || 0), 0);
+  }
+
+  get unavailableMachines() {
+    if (this.isReady) {
+      const names = this.machines.filter((machine) => {
+        return machine.status?.conditions?.find((c) => c.error && c.type === 'NodeHealthy');
+      }).map((machine) => {
+        if (machine.status?.nodeRef?.name) {
+          return this.t('cluster.availabilityWarnings.node', { name: machine.status.nodeRef.name });
+        }
+
+        return this.t('cluster.availabilityWarnings.machine', { name: machine.metadata.name });
+      });
+
+      return names.join('<br>');
+    }
+
+    return '';
+  }
+
+  // nodeGroups can be undefined for an EKS cluster that has just been created and has not
+  // had any node groups added to it
+  get eksNodeGroups() {
+    return this.spec?.eksConfig?.nodeGroups || [];
+  }
+
   // Color to use as the underline for the icon in the app bar
   get iconColor() {
     return this.metadata?.annotations?.[CLUSTER_BADGE.COLOR];
@@ -354,8 +592,8 @@ export default class MgmtCluster extends SteveModel {
   }
 
   get availableCpu() {
-    const reserved = parseSi(this.status.requested?.cpu);
-    const allocatable = parseSi(this.status.allocatable?.cpu);
+    const reserved = parseSi(this.status?.requested?.cpu);
+    const allocatable = parseSi(this.status?.allocatable?.cpu);
 
     if ( allocatable > 0 && reserved >= 0 ) {
       return Math.max(0, allocatable - reserved);
@@ -365,8 +603,8 @@ export default class MgmtCluster extends SteveModel {
   }
 
   get availableMemory() {
-    const reserved = parseSi(this.status.requested?.memory);
-    const allocatable = parseSi(this.status.allocatable?.memory);
+    const reserved = parseSi(this.status?.requested?.memory);
+    const allocatable = parseSi(this.status?.allocatable?.memory);
 
     if ( allocatable > 0 && reserved >= 0 ) {
       return Math.max(0, allocatable - reserved);
@@ -450,17 +688,23 @@ export default class MgmtCluster extends SteveModel {
     }, initialAggregation);
   }
 
-  get nodes() {
-    return this.$getters['all'](MANAGEMENT.NODE).filter((node) => node.id.startsWith(this.id));
+  get normanCluster() {
+    return this.$rootGetters['rancher/byId'](NORMAN.CLUSTER, this.id);
+  }
+
+  async findNormanCluster() {
+    return await this.$dispatch('rancher/find', { type: NORMAN.CLUSTER, id: this.id }, { root: true });
+  }
+
+  get provCluster() {
+    return this.$rootGetters['management/byId'](CAPI.RANCHER_CLUSTER, this.provClusterId);
   }
 
   get provClusterId() {
-    const isRKE1 = !!this.spec?.rancherKubernetesEngineConfig;
-    // Note: RKE1 provisioning cluster IDs are in a different format. For example,
-    // RKE2 cluster IDs include the name - fleet-default/cluster-name - whereas an RKE1
-    // cluster has the less human readable management cluster ID in it: fleet-default/c-khk48
+    // Note - there's also status.info.provisioningClusterReg, which is a link to the lifecycle owning type
+    // for v2prov this would be a provisioning.cattle.io.cluster, but for others it wouldn't be.
 
-    const verb = this.isLocal || isRKE1 || this.isHostedKubernetesProvider ? 'to' : 'from';
+    const verb = this.isLocal || this.isHostedKubernetesProvider ? 'to' : 'from';
     const res = findRelationship(verb, CAPI.RANCHER_CLUSTER, this.metadata?.relationships);
 
     if (res) {
@@ -470,6 +714,20 @@ export default class MgmtCluster extends SteveModel {
     return findRelationship(verb === 'to' ? 'from' : 'to', CAPI.RANCHER_CLUSTER, this.metadata?.relationships);
   }
 
+  get provClusterNamespace() {
+    // Could consider using `metadata.annotations."objectset.rio.cattle.io/owner-namespace"` instead of provClusterId from resource rels
+    const [namespace] = this.provClusterId?.split('/') || [];
+
+    return namespace;
+  }
+
+  get provClusterName() {
+    // Could consider using `metadata.annotations."objectset.rio.cattle.io/owner-name"` instead of provClusterId from resource rels
+    const [, name] = this.provClusterId?.split('/') || [];
+
+    return name;
+  }
+
   get pinned() {
     return this.$rootGetters['prefs/get'](PINNED_CLUSTERS).includes(this.id);
   }
@@ -489,4 +747,70 @@ export default class MgmtCluster extends SteveModel {
 
     this.$dispatch('prefs/set', { key: PINNED_CLUSTERS, value: types }, { root: true });
   }
+
+  get canExplore() {
+    return this.isReady && !this.hasError;
+  }
+
+  get hasError() {
+    // TODO: kinara - this was copied over from prov cluster. prov conditions vs mgmt conditions
+    // Before we were just checking for this.status?.conditions?.some((condition) => condition.error === true)
+    // but this is wrong as an error might exist but it might not be meaningful in the context of readiness of a cluster
+    // which is what this 'hasError' is used for.
+    // We now check if there's a ready condition after an error, which helps dictate the readiness of a cluster
+    // Based on the findings in https://github.com/rancher/dashboard/issues/10043
+    if (this.status?.conditions && this.status?.conditions.length) {
+      // if there are errors, we compare with how recent the "Ready" condition is compared to that error, otherwise we just move on
+      if (this.status?.conditions.some((c) => c.error === true)) {
+        // there's no ready condition and has an error, mark it
+        if (!this.status?.conditions.some((c) => c.type === 'Ready')) {
+          return true;
+        }
+
+        const filteredConditions = this.status?.conditions.filter((c) => c.error === true || c.type === 'Ready');
+        const mostRecentCondition = filteredConditions.reduce((a, b) => ((a.lastUpdateTime > b.lastUpdateTime) ? a : b));
+
+        return mostRecentCondition.error;
+      }
+    }
+
+    return false;
+  }
+
+  get isAutoscalerEnabled() {
+    if (!this.provCluster) {
+      return false;
+    }
+
+    return !!this.provCluster.spec?.rkeConfig?.machinePools?.some((pool) => {
+      return typeof pool.autoscalingMinSize !== 'undefined' || typeof pool.autoscalingMaxSize !== 'undefined';
+    });
+  }
+
+  _statusInfoWarned = false;
+  get statusInfo() {
+    if (!this.status.info) {
+      if (!this._statusInfoWarned) {
+        this._statusInfoWarned = true;
+        // eslint-disable-next-line no-console
+        console.warn(`management.cattle.io.cluster '${ this.id }' is missing 'status.info'. This could mean the resource is troubled, or an extension has brought in this new model which is used in an older rancher`);
+      }
+
+      return { };
+    }
+
+    return this.status.info;
+  }
+
+  async goToHarvesterCluster() {
+    const harvesterCluster = await this.$dispatch('create', {
+      ...this.provCluster,
+      type: HCI.CLUSTER
+    });
+
+    try {
+      await harvesterCluster.goToCluster();
+    } catch {
+    }
+  }
 }

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

@@ -8,7 +8,7 @@ export default class Feature extends HybridModel {
 
   get enabled() {
     // If lockedValue is not null, then this is the value that the flag is locked to, so that should be used
-    if (this.status.lockedValue !== null) {
+    if (this.status && this.status.lockedValue !== null) {
       return this.status.lockedValue;
     }
 
@@ -17,7 +17,7 @@ export default class Feature extends HybridModel {
   }
 
   get restartRequired() {
-    return !this.status.dynamic;
+    return !this.status?.dynamic;
   }
 
   get canYaml() {
@@ -43,7 +43,7 @@ export default class Feature extends HybridModel {
     // User can not disable or enable if the feature flag is locked
     // Note: lockedValue is the value that the feature flag is locked to, so it can be true or false
     // It can also be null, which indicates that the feature flag is not locked
-    enableAction.enabled = enableAction.enabled && (this.status.lockedValue === null);
+    enableAction.enabled = enableAction.enabled && (this.status && this.status.lockedValue === null);
 
     out.unshift(enableAction);
 

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

@@ -2,10 +2,9 @@ import HybridModel from '@shell/plugins/steve/hybrid-class';
 
 const HIDDEN = ['rke', 'rancherkubernetesengine'];
 
-const V2 = ['amazoneks', 'googlegke', 'azureaks'];
 const IMPORTABLE = ['amazoneks', 'googlegke', 'azureaks'];
 
-// The Ember create page has short names that don't match the full kontainer driver
+// Short names that map from the full kontainer driver name
 export const KONTAINER_TO_DRIVER = {
   amazonelasticcontainerservice:    'amazoneks',
   azurekubernetesservice:           'azureaks',
@@ -36,14 +35,6 @@ export const KEV1 = [
   'googlekubernetesengine',
 ];
 
-// And the Import page has even shorter ones that don't match kontainer or create...
-export const DRIVER_TO_IMPORT = {
-  googlegke: 'gke',
-  amazoneks: 'eks',
-  azureaks:  'aks',
-  alibaba:   'alibabacloud'
-};
-
 export default class KontainerDriver extends HybridModel {
   get showCreate() {
     if ( HIDDEN.includes(this.driverName) ) {
@@ -57,22 +48,6 @@ export default class KontainerDriver extends HybridModel {
     return this.showCreate && IMPORTABLE.includes(this.driverName);
   }
 
-  get emberCreatePath() {
-    let driver = this.driverName;
-
-    if ( V2.includes(driver) && !driver.endsWith('v2') ) {
-      driver += 'v2';
-    }
-
-    return `/g/clusters/add/launch/${ driver }`;
-  }
-
-  get emberImportPath() {
-    const provider = DRIVER_TO_IMPORT[this.driverName] || this.driverName;
-
-    return `/g/clusters/add/launch/import?importProvider=${ provider }`;
-  }
-
   get driverName() {
     if (!this.spec.builtIn) {
       // if the driver is not built in, there's a good change its a custom one