@rancher/shell 3.0.7 → 3.0.8-rc.1

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/dynamic-content/__tests__/config.test.ts

@@ -0,0 +1,187 @@
+import { getConfig } from '../config';
+import { SETTING } from '@shell/config/settings';
+import * as version from '@shell/config/version';
+
+const DEFAULT_ENDPOINT = 'https://updates.rancher.io/rancher/$dist/updates';
+
+// Mock dependencies
+jest.mock('@shell/config/version', () => ({ getVersionData: jest.fn(), isRancherPrime: jest.fn() }));
+
+describe('getConfig', () => {
+  let mockGetters: any;
+
+  beforeEach(() => {
+    // Reset mocks before each test
+    (version.getVersionData as jest.Mock).mockClear();
+    (version.isRancherPrime as jest.Mock).mockClear();
+
+    // Default mock for getters
+    mockGetters = { 'management/byId': jest.fn() };
+  });
+
+  describe('community distribution', () => {
+    beforeEach(() => {
+      (version.getVersionData as jest.Mock).mockReturnValue({ RancherPrime: 'false' });
+      (version.isRancherPrime as jest.Mock).mockReturnValue(false);
+    });
+
+    it('should return default community config when no settings are present', () => {
+      mockGetters['management/byId'].mockReturnValue(null);
+      const config = getConfig(mockGetters);
+
+      expect(config.prime).toBe(false);
+      expect(config.distribution).toBe('community');
+      expect(config.endpoint).toBe(DEFAULT_ENDPOINT);
+      expect(config.enabled).toBe(true);
+      expect(config.debug).toBe(false);
+      expect(config.log).toBe(false);
+    });
+
+    it('should enable debug and log modes when enabled setting is "debug"', () => {
+      mockGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (id === SETTING.DYNAMIC_CONTENT_ENABLED) {
+          return { value: 'debug' };
+        }
+        if (id === SETTING.DYNAMIC_CONTENT_ENDPOINT) {
+          return { value: 'https://test.endpoint' };
+        }
+
+        return null;
+      });
+
+      const config = getConfig(mockGetters);
+
+      expect(config.enabled).toBe(true);
+      expect(config.debug).toBe(true);
+      expect(config.log).toBe(true);
+    });
+
+    it('should enable log mode when enabled setting is "log"', () => {
+      mockGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (id === SETTING.DYNAMIC_CONTENT_ENABLED) {
+          return { value: 'log' };
+        }
+        if (id === SETTING.DYNAMIC_CONTENT_ENDPOINT) {
+          return { value: 'https://test.endpoint' };
+        }
+
+        return null;
+      });
+
+      const config = getConfig(mockGetters);
+
+      expect(config.enabled).toBe(true);
+      expect(config.debug).toBe(false);
+      expect(config.log).toBe(true);
+    });
+
+    it('should not use the endpoint from settings when community', () => {
+      mockGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (id === SETTING.DYNAMIC_CONTENT_ENDPOINT) {
+          return { value: 'https://custom.endpoint/rancher/$dist' };
+        }
+
+        return null;
+      });
+
+      const config = getConfig(mockGetters);
+
+      expect(config.endpoint).toBe(DEFAULT_ENDPOINT);
+      expect(config.enabled).toBe(true);
+    });
+  });
+
+  describe('prime distribution', () => {
+    beforeEach(() => {
+      (version.getVersionData as jest.Mock).mockReturnValue({ RancherPrime: 'true' });
+      (version.isRancherPrime as jest.Mock).mockReturnValue(true);
+    });
+
+    it('should return default prime config when no settings are present', () => {
+      mockGetters['management/byId'].mockReturnValue(null);
+      const config = getConfig(mockGetters);
+
+      expect(config.prime).toBe(true);
+      expect(config.distribution).toBe('prime');
+      expect(config.endpoint).toBe(DEFAULT_ENDPOINT);
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should be disabled when the setting is "false"', () => {
+      mockGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (id === SETTING.DYNAMIC_CONTENT_ENABLED) {
+          return { value: 'false' };
+        }
+        if (id === SETTING.DYNAMIC_CONTENT_ENDPOINT) {
+          return { value: 'https://test.endpoint' };
+        }
+
+        return null;
+      });
+
+      const config = getConfig(mockGetters);
+
+      expect(config.enabled).toBe(false);
+    });
+
+    it('should be enabled when the setting is "true"', () => {
+      mockGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (id === SETTING.DYNAMIC_CONTENT_ENABLED) {
+          return { value: 'true' };
+        }
+        if (id === SETTING.DYNAMIC_CONTENT_ENDPOINT) {
+          return { value: 'https://test.endpoint' };
+        }
+
+        return null;
+      });
+
+      const config = getConfig(mockGetters);
+
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should NOT use the endpoint from settings if it is not a valid HTTPS URL', () => {
+      mockGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (id === SETTING.DYNAMIC_CONTENT_ENDPOINT) {
+          return { value: 'http://insecure.endpoint/rancher/$dist' };
+        }
+
+        return null;
+      });
+
+      const config = getConfig(mockGetters);
+
+      expect(config.endpoint).toBe(DEFAULT_ENDPOINT); // Falls back to default
+      expect(config.enabled).toBe(true);
+    });
+  });
+
+  describe('general', () => {
+    it('should handle exceptions when reading settings and return defaults', () => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+      const testError = new Error('Something went wrong');
+
+      (version.getVersionData as jest.Mock).mockReturnValue({ RancherPrime: 'false' });
+      (version.isRancherPrime as jest.Mock).mockReturnValue(false);
+      mockGetters['management/byId'].mockImplementation(() => {
+        throw testError;
+      });
+
+      const config = getConfig(mockGetters);
+
+      // It should fall back to the default configuration
+      expect(config.prime).toBe(false);
+      expect(config.distribution).toBe('community');
+      expect(config.endpoint).toBe(DEFAULT_ENDPOINT);
+      expect(config.enabled).toBe(true);
+      expect(config.debug).toBe(false);
+      expect(config.log).toBe(false);
+
+      // And it should log the error
+      expect(consoleErrorSpy).toHaveBeenCalledWith('Error reading dynamic content settings', testError);
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+});