@rancher/shell 3.0.7 → 3.0.8-rc.10

package/utils/__tests__/selector-typed.test.ts

@@ -0,0 +1,263 @@
+import { labelSelectorToSelector } from '@shell/utils/selector-typed';
+import { KubeLabelSelector } from '@shell/types/kube/kube-api';
+
+describe('selector-typed', () => {
+  describe('labelSelectorToSelector', () => {
+    describe('empty label selectors', () => {
+      it('should return empty string for undefined label selector', () => {
+        const result = labelSelectorToSelector(undefined);
+
+        expect(result).toBe('');
+      });
+
+      it('should return empty string for label selector with no matchLabels and no matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = {};
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('');
+      });
+
+      it('should return empty string for label selector with empty matchLabels', () => {
+        const labelSelector: KubeLabelSelector = { matchLabels: {} };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('');
+      });
+
+      it('should return empty string for label selector with empty matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = { matchExpressions: [] };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('');
+      });
+
+      it('should return empty string for label selector with both empty matchLabels and matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels:      {},
+          matchExpressions: []
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('');
+      });
+    });
+
+    describe('matchLabels conversion', () => {
+      it('should convert single matchLabel to selector string', () => {
+        const labelSelector: KubeLabelSelector = { matchLabels: { app: 'nginx' } };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app=nginx');
+      });
+
+      it('should convert multiple matchLabels to comma-separated selector string', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels: {
+            app:     'nginx',
+            version: 'v1.0',
+            env:     'production'
+          }
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app=nginx,version=v1.0,env=production');
+      });
+
+      it('should handle matchLabels with special characters', () => {
+        const labelSelector: KubeLabelSelector = { matchLabels: { 'app.kubernetes.io/name': 'my-app' } };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app.kubernetes.io/name=my-app');
+      });
+
+      it('should handle matchLabels with numeric values', () => {
+        const labelSelector: KubeLabelSelector = { matchLabels: { tier: '3' } };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('tier=3');
+      });
+    });
+
+    describe('matchExpressions conversion with In operator', () => {
+      it('should convert matchExpression with In operator and single value to equality selector', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'app',
+              operator: 'In',
+              values:   ['nginx']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app=nginx');
+      });
+
+      it('should convert matchExpression with In operator and multiple values to in() selector', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['dev', 'staging', 'prod']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('env in (dev,staging,prod)');
+      });
+
+      it('should convert multiple matchExpressions with In operator', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'app',
+              operator: 'In',
+              values:   ['nginx']
+            },
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['dev', 'staging']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app=nginx,env in (dev,staging)');
+      });
+
+      it('should handle matchExpression with empty values array for In operator', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'app',
+              operator: 'In',
+              values:   []
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        // With empty values array, it should create an in() with no values
+        expect(result).toBe('app in ()');
+      });
+    });
+
+    describe('combined matchLabels and matchExpressions', () => {
+      it('should combine matchLabels and matchExpressions with single values', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels:      { tier: 'frontend' },
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['prod']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('tier=frontend,env=prod');
+      });
+
+      it('should combine multiple matchLabels and matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels: {
+            tier:    'frontend',
+            version: 'v2'
+          },
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['dev', 'staging']
+            },
+            {
+              key:      'region',
+              operator: 'In',
+              values:   ['us-west-1']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('tier=frontend,version=v2,env in (dev,staging),region=us-west-1');
+      });
+
+      it('should combine matchLabels with multiple matchExpressions using in() notation', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels:      { 'app.kubernetes.io/name': 'myapp' },
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'In',
+              values:   ['dev', 'test', 'prod']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        expect(result).toBe('app.kubernetes.io/name=myapp,env in (dev,test,prod)');
+      });
+    });
+
+    describe('unsupported operators', () => {
+      it('should throw error for NotIn operator', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'env',
+              operator: 'NotIn',
+              values:   ['prod']
+            }
+          ]
+        };
+
+        expect(() => labelSelectorToSelector(labelSelector)).toThrow('Unsupported matchExpression found when converting to selector string.');
+      });
+    });
+
+    describe('edge cases', () => {
+      it('should handle matchExpression with In operator but undefined values', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchExpressions: [
+            {
+              key:      'app',
+              operator: 'In',
+              values:   undefined
+            }
+          ]
+        };
+
+        // When values is undefined, the function throws an error
+        expect(() => labelSelectorToSelector(labelSelector)).toThrow('Unsupported matchExpression found when converting to selector string.');
+      });
+
+      it('should preserve order of matchLabels and matchExpressions', () => {
+        const labelSelector: KubeLabelSelector = {
+          matchLabels: {
+            first:  'value1',
+            second: 'value2'
+          },
+          matchExpressions: [
+            {
+              key:      'third',
+              operator: 'In',
+              values:   ['value3']
+            }
+          ]
+        };
+        const result = labelSelectorToSelector(labelSelector);
+
+        // matchLabels come before matchExpressions
+        expect(result).toContain('first=value1');
+        expect(result).toContain('second=value2');
+        expect(result).toContain('third=value3');
+        expect(result.indexOf('first')).toBeLessThan(result.indexOf('third'));
+      });
+    });
+  });
+});

package/utils/__tests__/version.test.ts

@@ -1,4 +1,4 @@
-import { isDevBuild } from '@shell/utils/version';
+import { isDevBuild, isUpgradeFromPreToStable } from '@shell/utils/version';
 
 describe('fx: isDevBuild', () => {
   it.each([
@@ -16,3 +16,21 @@ describe('fx: isDevBuild', () => {
     }
   );
 });
+
+describe('fx: isUpgradeFromPreToStable', () => {
+  it('should be true when going from pre-release to stable of same version', () => {
+    expect(isUpgradeFromPreToStable('1.0.0-rc1', '1.0.0')).toBe(true);
+  });
+
+  it('should be false when going from stable to pre-release', () => {
+    expect(isUpgradeFromPreToStable('1.0.0', '1.0.0-rc1')).toBe(false );
+  });
+
+  it('should be false for stable to stable', () => {
+    expect(isUpgradeFromPreToStable('1.0.0', '1.1.0')).toBe(false);
+  });
+
+  it('should be false for pre-release to pre-release', () => {
+    expect(isUpgradeFromPreToStable('1.0.0-rc1', '1.0.0-rc2')).toBe(false);
+  });
+});

package/utils/autoscaler-utils.ts

@@ -0,0 +1,7 @@
+import { AUTOSCALER } from '@shell/store/features';
+
+export function isAutoscalerFeatureFlagEnabled(store: any): boolean {
+  const rootGetters = store.rootGetters || store.getters;
+
+  return rootGetters['features/get'](AUTOSCALER);
+}

package/utils/back-off.ts

@@ -137,9 +137,9 @@ class BackOff {
 
       // First step is immediate (0.001s)
       // Second and others are exponential
-      // 1,      2,     3,  4,     5,  6,      7,   8,      9
-      // 1,      4,     9, 16,    25, 36,     49,  64,     81
-      // 0.25s, 1s, 2.25s, 4s, 6.25s, 9s, 12.25s, 16s, 20.25s
+      // Try:         1,     2,   3,     4,    5,      6,    7,       8,    9
+      // Multiple:    1,     4,   9,     16,   25,     36,   49,      64,   81
+      // Actual Time: 0.25s, 1s,  2.25s, 4s,   6.25s,  9s,   12.25s,  16s,  20.25s
       const delay = backOffTry === 0 ? 1 : Math.pow(backOffTry, 2) * 250;
 
       this.log('info', id, `Delaying call (attempt ${ backOffTry + 1 }, delayed by ${ delay }ms)`, description);

package/utils/brand.ts

@@ -0,0 +1,29 @@
+/**
+ * Brand/Theme metadata
+ */
+export interface BrandMeta {
+  // Does the banner have a stylesheet?
+  hasStylesheet?: string;
+  banner?: {
+    // Text alignment for the banner text overlayed on the banner image
+    textAlign?: string;
+  }
+}
+
+/**
+ * Get the brand/theme meta information for the specified brand
+ *
+ * @param brand - The brand identifier
+ * @returns Brand meta information or empty object if none available
+ */
+export function getBrandMeta(brand: string): BrandMeta {
+  let brandMeta: BrandMeta = {};
+
+  if (brand) {
+    try {
+      brandMeta = require(`~shell/assets/brand/${ brand }/metadata.json`);
+    } catch {}
+  }
+
+  return brandMeta;
+}

package/utils/chart.js

@@ -0,0 +1,18 @@
+import { compatibleVersionsFor } from '@shell/store/catalog';
+
+/**
+ * Get the latest chart version that is compatible with the cluster's OS and user's pre-release preference.
+ * @param {Object} chart - The chart object.
+ * @param {Array<string>} workerOSs - The list of worker OSs for the cluster.
+ * @param {boolean} showPrerelease - Whether to include pre-release versions.
+ * @returns {Object} The latest compatible chart version object.
+ */
+export function getLatestCompatibleVersion(chart, workerOSs, showPrerelease) {
+  if (!chart?.versions?.length) {
+    return {};
+  }
+
+  const compatible = compatibleVersionsFor(chart, workerOSs, showPrerelease);
+
+  return (compatible.length ? compatible[0] : chart.versions[0]) || {};
+}

package/utils/cluster.js

@@ -8,8 +8,8 @@ import { compare, sortable } from '@shell/utils/version';
 import { sortBy } from '@shell/utils/sort';
 import { HARVESTER_CONTAINER, SCHEDULING_CUSTOMIZATION } from '@shell/store/features';
 import { _CREATE, _EDIT } from '@shell/config/query-params';
-import isEmpty from 'lodash/isEmpty';
-import { set } from '@shell/utils/object';
+import isEmptyLodash from 'lodash/isEmpty';
+import { set, diff, isEmpty, clone } from '@shell/utils/object';
 
 /**
  * Combination of paginationFilterHiddenLocalCluster and paginationFilterOnlyKubernetesClusters
@@ -323,7 +323,7 @@ export async function initSchedulingCustomization(value, features, store, mode)
     errors.push(e);
   }
 
-  if (schedulingCustomizationFeatureEnabled && mode === _CREATE && isEmpty(value?.clusterAgentDeploymentCustomization?.schedulingCustomization)) {
+  if (schedulingCustomizationFeatureEnabled && mode === _CREATE && isEmptyLodash(value?.clusterAgentDeploymentCustomization?.schedulingCustomization)) {
     set(value, 'clusterAgentDeploymentCustomization.schedulingCustomization', { priorityClass: clusterAgentDefaultPC, podDisruptionBudget: clusterAgentDefaultPDB });
   }
 
@@ -335,3 +335,157 @@ export async function initSchedulingCustomization(value, features, store, mode)
     clusterAgentDefaultPC, clusterAgentDefaultPDB, schedulingCustomizationFeatureEnabled, schedulingCustomizationOriginallyEnabled, errors
   };
 }
+
+/**
+ * Recursively filters a `diffs` object to only include differences that are relevant to the user.
+ * A difference is considered relevant if the user has provided a custom value for that specific field.
+ *
+ * @param {object} diffs - The object representing the differences between two chart versions' default values.
+ * @param {object} userVals - The object containing the user's custom values.
+ * @returns {object} A new object containing only the relevant differences.
+ */
+export function _addonConfigPreserveFilter(diffs, userVals) {
+  const filtered = {};
+
+  for (const key of Object.keys(diffs)) {
+    const diffVal = diffs[key];
+    const userVal = userVals?.[key];
+
+    const isDiffObject = typeof diffVal === 'object' && diffVal !== null && !Array.isArray(diffVal);
+    const isUserObject = typeof userVal === 'object' && userVal !== null && !Array.isArray(userVal);
+
+    // If both the diff and user value are objects, we need to recurse into them.
+    if (isDiffObject && isUserObject) {
+      const nestedFiltered = _addonConfigPreserveFilter(diffVal, userVal);
+
+      if (!isEmpty(nestedFiltered)) {
+        filtered[key] = nestedFiltered;
+      }
+    } else if (userVal !== undefined) {
+      // If the user has provided a value for this key, the difference is relevant.
+      filtered[key] = diffVal;
+    }
+  }
+
+  return filtered;
+}
+
+/**
+ * Processes a single add-on version change. It fetches the old and new chart information,
+ * calculates the differences in default values, and filters them based on user's customizations.
+ * If there are no significant differences, it preserves the user's custom values for the new version.
+ *
+ * @param {object} store The Vuex store.
+ * @param {object} userChartValues The user's customized chart values.
+ * @param {string} chartName The name of the chart to process.
+ * @param {object} oldAddon The addon information from the previous Kubernetes version.
+ * @param {object} newAddon The addon information from the new Kubernetes version.
+ * @returns {object|null} An object containing the diff and a preserve flag, or null on error.
+ */
+async function _addonConfigPreserveProcess(store, userChartValues, chartName, oldAddon, newAddon) {
+  if (chartName.includes('none')) {
+    return null;
+  }
+
+  try {
+    const [oldVersionInfo, newVersionInfo] = await Promise.all([
+      store.dispatch('catalog/getVersionInfo', {
+        repoType:    'cluster',
+        repoName:    oldAddon.repo,
+        chartName,
+        versionName: oldAddon.version,
+      }),
+      store.dispatch('catalog/getVersionInfo', {
+        repoType:    'cluster',
+        repoName:    newAddon.repo,
+        chartName,
+        versionName: newAddon.version,
+      })
+    ]);
+
+    const oldDefaults = oldVersionInfo.values;
+    const newDefaults = newVersionInfo.values;
+    const defaultsDifferences = diff(oldDefaults, newDefaults);
+
+    const userOldValues = userChartValues[`${ chartName }-${ oldAddon.version }`];
+
+    // We only care about differences in values that the user has actually customized.
+    // If the user hasn't touched a value, a change in its default should not be considered a breaking change.
+    const defaultsAndUserDifferences = userOldValues ? _addonConfigPreserveFilter(defaultsDifferences, userOldValues) : {};
+
+    return {
+      diff:     defaultsAndUserDifferences,
+      preserve: isEmpty(defaultsAndUserDifferences)
+    };
+  } catch (e) {
+    console.error(`Failed to get chart version info for diff for chart ${ chartName }`, e); // eslint-disable-line no-console
+
+    return null;
+  }
+}
+
+/**
+ * @typedef {object} AddonPreserveContext
+ * @property {object} addonConfigDiffs - An object that stores the diffs.
+ * @property {string[]} addonNames - An array of addon names to check.
+ * @property {object} $store - The Vuex store.
+ * @property {object} userChartValues - The user's customized chart values.
+ *
+ * When the Kubernetes version is changed, this method is called to handle the add-on configurations
+ * for all enabled addons. It checks if an addon's version has changed and, if so, determines if the
+ * user's custom configurations should be preserved for the new version.
+ *
+ * The goal is to avoid showing a confirmation dialog for changes in default values that the user has not customized.
+ *
+ * @param {AddonPreserveContext} context The context object from the component.
+ * @param {object} oldCharts The charts object from the K8s release object being changed from.
+ * @param {object} newCharts The charts object from the K8s release object being changed to.
+ */
+export async function addonConfigPreserve(context, oldCharts, newCharts) {
+  const {
+    addonConfigDiffs,
+    addonNames,
+    $store,
+    userChartValues
+  } = context;
+
+  if (!oldCharts || !newCharts) {
+    return;
+  }
+
+  // Clear the diffs object for the new run
+  for (const key in addonConfigDiffs) {
+    delete addonConfigDiffs[key];
+  }
+
+  // Iterate through the addons that are enabled for the cluster.
+  for (const chartName of addonNames) {
+    const oldAddon = oldCharts[chartName];
+    const newAddon = newCharts[chartName];
+
+    // If the addon didn't exist in the old K8s version, there's nothing to compare.
+    if (!oldAddon) {
+      continue;
+    }
+
+    // Check if the add-on version has changed.
+    if (newAddon && newAddon.version !== oldAddon.version) {
+      const result = await _addonConfigPreserveProcess($store, userChartValues, chartName, oldAddon, newAddon);
+
+      if (result) {
+        addonConfigDiffs[chartName] = result.diff;
+
+        if (result.preserve) {
+          const oldKey = `${ chartName }-${ oldAddon.version }`;
+          const newKey = `${ chartName }-${ newAddon.version }`;
+
+          // If custom values exist for the old version, and none exist for the new version,
+          // copy the values to the new key to preserve them.
+          if (userChartValues[oldKey] && !userChartValues[newKey]) {
+            userChartValues[newKey] = clone(userChartValues[oldKey]);
+          }
+        }
+      }
+    }
+  }
+}

package/utils/color.js

@@ -13,7 +13,7 @@ Primary color classes from _light.scss
 
 */
 
-const Color = require('color');
+import Color from 'color';
 
 export function createCssVars(color, theme = 'light', name = 'primary') {
   const contrastOpts = theme === 'light' ? LIGHT_CONTRAST_COLORS : DARK_CONTRAST_COLORS;