@rancher/shell 3.0.7 → 3.0.8-rc.2

package/utils/__tests__/cluster.test.ts

@@ -1,4 +1,5 @@
-import { abbreviateClusterName } from '@shell/utils/cluster';
+import { abbreviateClusterName, _addonConfigPreserveFilter, addonConfigPreserve } from '@shell/utils/cluster';
+import { diff } from '@shell/utils/object';
 
 describe('fx: abbreviateClusterName', () => {
   it.each([
@@ -55,3 +56,380 @@ describe('fx: abbreviateClusterName', () => {
     expect(result).toStrictEqual(expected);
   });
 });
+
+describe('fx: _addonConfigPreserveFilter', () => {
+  it('should return an empty object if there are no differences between default values', () => {
+    const oldDefaults = { replicaCount: 1 };
+    const newDefaults = { replicaCount: 1 };
+    const userVals = { replicaCount: 3 };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should return an empty object if no user values are provided', () => {
+    const oldDefaults = { replicaCount: 1 };
+    const newDefaults = { replicaCount: 2 };
+    const userVals = {};
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should filter out diffs for fields not customized by the user', () => {
+    const oldDefaults = {
+      replicaCount: 1,
+      persistence:  false
+    };
+    const newDefaults = {
+      replicaCount: 2,
+      persistence:  true
+    };
+    const userVals = { replicaCount: 3 };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { replicaCount: 2 };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should include diffs for fields customized by the user', () => {
+    const oldDefaults = { replicaCount: 1 };
+    const newDefaults = { replicaCount: 2 };
+    const userVals = { replicaCount: 3 };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { replicaCount: 2 };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle nested objects: include diff if user customized nested property', () => {
+    const oldDefaults = { service: { port: 80 } };
+    const newDefaults = { service: { port: 8080 } };
+    const userVals = { service: { port: 9000 } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { service: { port: 8080 } };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle nested objects: exclude diff if user did not customize nested property', () => {
+    const oldDefaults = { service: { port: 80, type: 'ClusterIP' } };
+    const newDefaults = { service: { port: 8080, type: 'ClusterIP' } };
+    const userVals = { service: { type: 'NodePort' } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle nested objects: include diff if user customized a removed nested object', () => {
+    const oldDefaults = { service: { port: 80 } };
+    const newDefaults = {};
+    const userVals = { service: { port: 9000 } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { service: { port: null } };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle nested objects: exclude diff if a new property is added to default nested object and user did not customize it', () => {
+    const oldDefaults = { service: { port: 80 } };
+    const newDefaults = { service: { port: 80, type: 'ClusterIP' } };
+    const userVals = { service: { port: 80 } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle arrays of primitives: include diff if user customized array and default array changed', () => {
+    const oldDefaults = { ingress: { hosts: ['host1.com', 'host2.com'] } };
+    const newDefaults = { ingress: { hosts: ['host1.com', 'host3.com'] } };
+    const userVals = { ingress: { hosts: ['user.host.com'] } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { ingress: { hosts: ['host1.com', 'host3.com'] } };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle arrays of primitives: exclude diff if user did not customize array', () => {
+    const oldDefaults = { ingress: { hosts: ['host1.com', 'host2.com'] } };
+    const newDefaults = { ingress: { hosts: ['host1.com', 'host3.com'] } };
+    const userVals = { ingress: { enabled: true } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle arrays of objects: include diff if user customized array and default array changed', () => {
+    const oldDefaults = { service: { ports: [{ name: 'http', port: 80 }] } };
+    const newDefaults = { service: { ports: [{ name: 'http', port: 80 }, { name: 'https', port: 443 }] } };
+    const userVals = { service: { ports: [{ name: 'http', port: 8080 }] } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { service: { ports: [{ name: 'http', port: 80 }, { name: 'https', port: 443 }] } };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle arrays of objects: exclude diff if user did not customize array', () => {
+    const oldDefaults = { service: { ports: [{ name: 'http', port: 80 }] } };
+    const newDefaults = { service: { ports: [{ name: 'http', port: 80 }, { name: 'https', port: 443 }] } };
+    const userVals = { service: { type: 'ClusterIP' } };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle properties added/removed: include diff if user customized a removed property', () => {
+    const oldDefaults = { oldProperty: 'defaultValue' };
+    const newDefaults = {};
+    const userVals = { oldProperty: 'customValue' };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = { oldProperty: null };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle properties added/removed: exclude diff if user did not customize an added property', () => {
+    const oldDefaults = {};
+    const newDefaults = { newProperty: 'defaultValue' };
+    const userVals = { otherProp: 'value' };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {};
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+
+  it('should handle complex nested structures with multiple changes', () => {
+    const oldDefaults = {
+      replicaCount: 1,
+      image:        {
+        repository: 'nginx',
+        tag:        'stable'
+      },
+      service: {
+        type: 'ClusterIP',
+        port: 80
+      },
+      ingress: {
+        enabled: false,
+        hosts:   ['chart-example.local']
+      }
+    };
+    const newDefaults = {
+      replicaCount: 2,
+      image:        {
+        repository: 'nginx',
+        tag:        'mainline'
+      },
+      service: {
+        type: 'ClusterIP',
+        port: 80
+      },
+      ingress: {
+        enabled: true,
+        hosts:   ['chart-example.local', 'new.chart-example.local'],
+        tls:     true
+      }
+    };
+    const userVals = {
+      replicaCount: 3,
+      ingress:      { hosts: ['my.custom.host'] }
+    };
+    const diffs = diff(oldDefaults, newDefaults);
+    const expected = {
+      replicaCount: 2,
+      ingress:      { hosts: ['chart-example.local', 'new.chart-example.local'] }
+    };
+
+    expect(_addonConfigPreserveFilter(diffs, userVals)).toStrictEqual(expected);
+  });
+});
+
+describe('fx: addonConfigPreserve', () => {
+  const ADDON_NAME = 'rke2-my-addon';
+  const mockOldVersionCharts = {
+    [ADDON_NAME]: {
+      repo:    'repo',
+      version: '1.0.0'
+    }
+  };
+
+  const mockNewVersionCharts = {
+    [ADDON_NAME]: {
+      repo:    'repo',
+      version: '1.1.0'
+    }
+  };
+
+  const mockOldVersionInfo = {
+    values: {
+      replicas: 1,
+      service:  { type: 'ClusterIP' }
+    }
+  };
+
+  const mockNewVersionInfo = {
+    values: {
+      replicas:    2, // changed
+      service:     { type: 'ClusterIP' },
+      persistence: true // new
+    }
+  };
+
+  let mockStore: any;
+  let addonConfigDiffs: any;
+  let userChartValues: any;
+  let context: any;
+
+  beforeEach(() => {
+    mockStore = {
+      dispatch: jest.fn((action, payload) => {
+        if (action === 'catalog/getVersionInfo') {
+          if (payload.versionName === '1.0.0') {
+            return Promise.resolve(mockOldVersionInfo);
+          }
+          if (payload.versionName === '1.1.0') {
+            return Promise.resolve(mockNewVersionInfo);
+          }
+        }
+
+        return Promise.resolve({});
+      })
+    };
+    addonConfigDiffs = {};
+    userChartValues = {};
+    context = {
+      addonConfigDiffs,
+      addonNames: [ADDON_NAME],
+      $store:     mockStore,
+      userChartValues,
+    };
+  });
+
+  it('should identify no relevant changes if user has no custom values', async() => {
+    // No user overrides means no relevant differences.
+    context.userChartValues = {};
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({});
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toBeUndefined();
+  });
+
+  it('should identify no relevant changes if user custom values are for different fields', async() => {
+    // User overrides for non-differing fields should not be considered relevant.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { service: { type: 'NodePort' } } };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({});
+    // Since diffs are empty, user values should be preserved
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toStrictEqual({ service: { type: 'NodePort' } });
+  });
+
+  it('should identify relevant changes if user has customized a changed field', async() => {
+    // A user override on a changed default should be flagged as a relevant difference.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { replicas: 3 } };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({ replicas: 2 });
+    // Since diffs are NOT empty, user values should NOT be preserved
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toBeUndefined();
+  });
+
+  it('should not identify relevant changes for new fields not customized by user', async() => {
+    // New fields in the addon default values are not relevant if not customized by the user.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: {} };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    // The only diff is `replicas`, which user didn't touch. `persistence` is new but also not touched.
+    // So final diffs should be empty.
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({});
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toStrictEqual({});
+  });
+
+  it('should preserve user values if there are no relevant differences', async() => {
+    // User values should be carried over to the new version if no relevant diffs are found.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { service: { type: 'NodePort' } } };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({});
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toStrictEqual({ service: { type: 'NodePort' } });
+  });
+
+  it('should not preserve user values if there are relevant differences', async() => {
+    // User values should not be carried over if relevant diffs are found.
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { replicas: 3 } };
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({ replicas: 2 });
+    expect(context.userChartValues[`${ ADDON_NAME }-1.1.0`]).toBeUndefined();
+  });
+
+  it('should handle catalog API errors gracefully', async() => {
+    // Errors from fetching chart info should be caught and handled.
+    const error = new Error('catalog fetch failed');
+
+    jest.spyOn(context.$store, 'dispatch').mockImplementation().mockRejectedValue(error);
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toBeUndefined();
+    expect(errorSpy).toHaveBeenCalledWith(`Failed to get chart version info for diff for chart ${ ADDON_NAME }`, error);
+    errorSpy.mockRestore();
+  });
+
+  it('should do nothing if oldCharts is not provided', async() => {
+    await addonConfigPreserve(context, {}, mockNewVersionCharts);
+    expect(context.addonConfigDiffs).toStrictEqual({});
+    expect(mockStore.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should do nothing if newCharts is not provided', async() => {
+    await addonConfigPreserve(context, mockOldVersionCharts, {});
+    expect(context.addonConfigDiffs).toStrictEqual({});
+    expect(mockStore.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should do nothing if addon version is the same', async() => {
+    const mockNewVersionSame = {
+      [ADDON_NAME]: {
+        repo:    'repo',
+        version: '1.0.0'
+      }
+    };
+
+    await addonConfigPreserve(context, mockOldVersionCharts, mockNewVersionSame);
+    expect(context.addonConfigDiffs[ADDON_NAME]).toBeUndefined();
+    expect(mockStore.dispatch).not.toHaveBeenCalled();
+  });
+
+  it('should handle multiple addons', async() => {
+    const ADDON2_NAME = 'rke2-my-addon2';
+    const ADDON3_NAME = 'rke2-my-addon3'; // same version
+
+    const oldCharts = {
+      ...mockOldVersionCharts,
+      [ADDON2_NAME]: { repo: 'repo', version: '1.0.0' },
+      [ADDON3_NAME]: { repo: 'repo', version: '1.0.0' },
+    };
+    const newCharts = {
+      ...mockNewVersionCharts,
+      [ADDON2_NAME]: { repo: 'repo', version: '1.1.0' }, // changed version, but no user values
+      [ADDON3_NAME]: { repo: 'repo', version: '1.0.0' }, // same version
+    };
+
+    context.addonNames = [ADDON_NAME, ADDON2_NAME, ADDON3_NAME];
+    context.userChartValues = { [`${ ADDON_NAME }-1.0.0`]: { replicas: 3 } };
+
+    await addonConfigPreserve(context, oldCharts, newCharts);
+
+    expect(context.addonConfigDiffs[ADDON_NAME]).toStrictEqual({ replicas: 2 });
+    expect(context.addonConfigDiffs[ADDON2_NAME]).toStrictEqual({});
+    expect(context.addonConfigDiffs[ADDON3_NAME]).toBeUndefined();
+  });
+});

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]);
+          }
+        }
+      }
+    }
+  }
+}