@rancher/shell 3.0.7 → 3.0.8-rc.1

package/store/prefs.js

@@ -114,6 +114,12 @@ export const PROVISIONER = create('provisioner', _RKE2, { options: [_RKE1, _RKE2
 export const MENU_MAX_CLUSTERS = 10;
 // Prompt for confirm when scaling down node pool in GUI and save the pref
 export const SCALE_POOL_PROMPT = create('scale-pool-prompt', null, { parseJSON });
+
+// Dynamic content
+export const READ_NEW_RELEASE = create('read-new-release', '', { parseJSON });
+export const READ_SUPPORT_NOTICE = create('read-support-notice', '', { parseJSON });
+export const READ_UPCOMING_SUPPORT_NOTICE = create('read-upcoming-support-notice', '', { parseJSON });
+
 // --------------------
 
 const cookiePrefix = 'R_';

package/types/kube/kube-api.ts

@@ -30,5 +30,6 @@ export interface KubeMetadata {
 }
 
 export interface RancherKubeMetadata extends KubeMetadata {
-  namespace: string,
+  namespace?: string,
+  name: string
 }

package/types/rancher/index.d.ts

@@ -4,6 +4,7 @@ declare module '@rancher/auto-import' {
 
 declare module '@shell/store/type-map' {
   export function DSL(store: any, name: string): any;
+  export function isAdminUser(getters: any): boolean;
 }
 
 declare module '@shell/plugins/dashboard-store';

package/types/resources/settings.d.ts

@@ -20,14 +20,39 @@ export interface PaginationSettingsStore {
   }
 }
 
-/**
+/*
  * Determine which resources can utilise server-side pagination
  */
 export interface PaginationSettingsStores {
   [store: string]: PaginationSettingsStore
 }
 
-export type PaginationFeature = 'listAutoRefreshToggle' | 'listManualRefresh'
+/**
+ * Names of pagination features used in pagination settings (not featureflags)
+ */
+export type PaginationFeatureName = 'listAutoRefreshToggle' | 'listManualRefresh' | 'homePageCluster'
+
+export type PaginationFeatureHomePageClusterConfig = {
+  threshold: number,
+  results: number,
+  pagesPerRow: number
+}
+
+/**
+ * Details of a specific pagination feature
+ */
+export type PaginationFeature<Config = any> = {
+  version: number,
+  enabled: boolean,
+  configuration?: Config,
+}
+
+/**
+ * List of specific features that can be enabled / disabled
+ */
+export type PaginationSettingsFeatures = {
+  [key in PaginationFeatureName]?: PaginationFeature
+}
 
 /**
  * Settings to handle server side pagination
@@ -45,11 +70,7 @@ export interface PaginationSettings {
   /**
    * List of specific features that can be enabled / disabled
    */
-  features?: {
-    [key in PaginationFeature]: {
-      enabled: boolean,
-    }
-  },
+  features?: PaginationSettingsFeatures,
 
   /**
    * Debounce the amount of time between a resource changing and the backend sending a resource.changes message
@@ -82,6 +103,7 @@ type ManagedFields = {
   time: string;
 };
 
+// Note - this should now be @RancherKubeMetadata
 type Metadata = {
   creationTimestamp: string;
   fields: string[];

package/types/shell/index.d.ts

@@ -174,6 +174,7 @@ export const STEP: "step";
 export const LOGGED_OUT: "logged-out";
 export const IS_SSO: "is-sso";
 export const IS_SLO: "is-slo";
+export const IS_SESSION_IDLE: "is-session-idle";
 export const UPGRADED: "upgraded";
 export const TIMED_OUT: "timed-out";
 export const AUTH_TEST: "test";
@@ -2190,6 +2191,9 @@ export namespace MANAGEMENT {
     export let CLUSTER_PROXY_CONFIG: string;
     export let OIDC_CLIENT: string;
 }
+export namespace EXT {
+    let USER_ACTIVITY: string;
+}
 export namespace CAPI {
     let CAPI_CLUSTER: string;
     let MACHINE_DEPLOYMENT: string;
@@ -3671,6 +3675,7 @@ export const STEVE_CACHE: any;
 export const UIEXTENSION: any;
 export const PROVISIONING_PRE_BOOTSTRAP: any;
 export const SCHEDULING_CUSTOMIZATION: any;
+export const SCC: any;
 export namespace getters {
     function get(state: any, getters: any, rootState: any, rootGetters: any): (name: any) => any;
 }
@@ -3754,6 +3759,9 @@ export const _RKE2: "rke2";
 export const PROVISIONER: any;
 export const MENU_MAX_CLUSTERS: 10;
 export const SCALE_POOL_PROMPT: any;
+export const READ_NEW_RELEASE: any;
+export const READ_SUPPORT_NOTICE: any;
+export const READ_UPCOMING_SUPPORT_NOTICE: any;
 export function state(): {
     cookiesLoaded: boolean;
     data: {};
@@ -3980,6 +3988,57 @@ export function initSchedulingCustomization(value: any, features: any, store: an
     schedulingCustomizationOriginallyEnabled: boolean;
     errors: any[];
 }>;
+/**
+ * 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: object, userVals: object): object;
+/**
+ * @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 function addonConfigPreserve(context: AddonPreserveContext, oldCharts: object, newCharts: object): Promise<void>;
+export type AddonPreserveContext = {
+    /**
+     * - An object that stores the diffs.
+     */
+    addonConfigDiffs: object;
+    /**
+     * - An array of addon names to check.
+     */
+    addonNames: string[];
+    /**
+     * - The Vuex store.
+     */
+    $store: object;
+    /**
+     * - 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.
+     */
+    userChartValues: object;
+};
 }
 
 // @shell/utils/color

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