@rancher/shell 3.0.8-rc.7 → 3.0.8-rc.9

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/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/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;

package/utils/dynamic-content/__tests__/info.test.ts

@@ -96,6 +96,8 @@ describe('systemInfoProvider', () => {
         return undefined;
       }),
       'management/schemaFor': jest.fn(),
+      localCluster:           mockClusters.find((c) => c.id === 'local') || null,
+      'features/get':         jest.fn(() => 'abc'),
     };
 
     (version.getVersionData as jest.Mock).mockReturnValue({
@@ -128,6 +130,7 @@ describe('systemInfoProvider', () => {
     expect(qs).toContain('bl=en-US');
     expect(qs).toContain('bs=1024x768');
     expect(qs).toContain('ss=1920x1080');
+    expect(qs).toContain('ff-usc=abc');
   });
 
   it('should handle missing or partial data gracefully', () => {
@@ -159,6 +162,10 @@ describe('systemInfoProvider', () => {
 
     mockGetters['uiplugins/plugins'] = null; // No plugins
     mockGetters['auth/principalId'] = null; // No user
+    mockGetters['localCluster'] = null; // No clusters
+    mockGetters['features/get'] = () => {
+      throw new Error('unknown feature');
+    };
 
     const infoProvider = new SystemInfoProvider(mockGetters, {});
     const qs = infoProvider.buildQueryString();
@@ -175,6 +182,7 @@ describe('systemInfoProvider', () => {
     expect(qs).not.toContain('lnc=');
     expect(qs).not.toContain('xkn=');
     expect(qs).not.toContain('xcc=');
+    expect(qs).not.toContain('ff-usc=');
   });
 
   it('should handle getAll returning undefined when types are not registered', () => {
@@ -191,6 +199,7 @@ describe('systemInfoProvider', () => {
 
     mockGetters['auth/principalId'] = 'user-456';
     mockGetters['uiplugins/plugins'] = []; // No plugins
+    mockGetters['localCluster'] = null; // No clusters
 
     const infoProvider = new SystemInfoProvider(mockGetters, {});
     const qs = infoProvider.buildQueryString();
@@ -199,7 +208,6 @@ describe('systemInfoProvider', () => {
     expect(mockGetters['management/byId']).toHaveBeenCalledWith(MANAGEMENT.SETTING, 'install-uuid');
     expect(mockGetters['management/byId']).toHaveBeenCalledWith(MANAGEMENT.SETTING, 'server-version-type');
     expect(mockGetters['management/typeRegistered']).toHaveBeenCalledWith(COUNT);
-    expect(mockGetters['management/typeRegistered']).toHaveBeenCalledWith(MANAGEMENT.CLUSTER);
     expect(mockGetters['management/all']).not.toHaveBeenCalled();
 
     // Verify the query string is built with fallback or empty values
@@ -225,6 +233,16 @@ describe('systemInfoProvider', () => {
         return { id, value: '' }; // Empty values for all settings
       }
     });
+
+    // local cluster with missing properties
+    const localCluster = {
+      id:      'local',
+      isLocal: true,
+      status:  { nodeCount: 1 },
+      // kubernetesVersionBase is missing
+      // provisioner is missing
+    };
+
     mockGetters['management/all'].mockImplementation((type: string) => {
       if (type === MANAGEMENT.SETTING) {
         // Return settings, but with empty values
@@ -237,20 +255,14 @@ describe('systemInfoProvider', () => {
         return [{ counts: { [MANAGEMENT.CLUSTER]: { summary: { count: 1 } } } }];
       }
       if (type === MANAGEMENT.CLUSTER) {
-        // local cluster with missing properties
-        return [{
-          id:      'local',
-          isLocal: true,
-          status:  { nodeCount: 1 },
-          // kubernetesVersionBase is missing
-          // provisioner is missing
-        }];
+        return [localCluster];
       }
 
       return [];
     });
 
     mockGetters['auth/principalId'] = null; // No user
+    mockGetters['localCluster'] = localCluster;
 
     const infoProvider = new SystemInfoProvider(mockGetters, {});
     const qs = infoProvider.buildQueryString();

package/utils/dynamic-content/info.ts

@@ -10,6 +10,7 @@ import {
 import { SETTING } from '@shell/config/settings';
 import { getVersionData } from '@shell/config/version';
 import { SettingsInfo } from '@shell/utils/dynamic-content/types';
+import { STEVE_CACHE } from '@shell/store/features';
 
 const QS_VERSION = 'v1'; // Include a version number in the query string in case we want to version the set of params we are sending
 const UNKNOWN = 'unknown';
@@ -26,6 +27,29 @@ const SUSE_EXTENSIONS = [
   'virtual-clusters'
 ];
 
+type FeatureFlagInfos = {
+  [id: string]: {
+    /**
+     * Query param, in format `ff-<param>`
+     */
+    param: string,
+    /**
+      * The actual value used by the UI, roughly spec.value || status.default
+      */
+    value: string,
+  }
+};
+
+/**
+ * Explicit ff's to send
+ */
+const ffs: FeatureFlagInfos = {
+  [STEVE_CACHE]: {
+    param: 'usc',
+    value: '',
+  }
+};
+
 /**
  * System information that is collected and which can then be encoded into a query string in the dyanmic content request
  */
@@ -47,6 +71,7 @@ type SystemInfo = {
   browserSize: string;
   screenSize: string;
   language: string;
+  featureFlags: FeatureFlagInfos
 };
 
 /**
@@ -107,8 +132,7 @@ export class SystemInfoProvider {
     // High-level information from clusters
     const counts = this.getAll(getters, COUNT)?.[0]?.counts || {};
     const clusterCount = counts[MANAGEMENT.CLUSTER] || {};
-    const all = this.getAll(getters, MANAGEMENT.CLUSTER);
-    const localCluster = all ? all.find((c: any) => c.isLocal) : undefined;
+    const localCluster = getters['localCluster'];
 
     // Stats for installed extensions
     const uiExtensionList = getters['uiplugins/plugins'];
@@ -132,6 +156,19 @@ export class SystemInfoProvider {
     const screenSize = `${ window.screen?.width || '?' }x${ window.screen?.height || '?' }`;
     const browserSize = `${ window.innerWidth }x${ window.innerHeight }`;
 
+    const safeFfs = Object.entries(ffs).reduce((res, [id, ff]) => {
+      try {
+        res[id] = {
+          param: ff.param,
+          value: getters['features/get'](id),
+        };
+      } catch (e) {
+        console.debug(`Cannot include Feature Flag "${ id }" in dynamic feature request: `, e); // eslint-disable-line no-console
+      }
+
+      return res;
+    }, {} as FeatureFlagInfos);
+
     return {
       systemUUID,
       userHash,
@@ -147,6 +184,7 @@ export class SystemInfoProvider {
       screenSize,
       browserSize,
       language:           window.navigator?.language,
+      featureFlags:       safeFfs,
     };
   }
 
@@ -214,6 +252,10 @@ export class SystemInfoProvider {
       params.push(`ss=${ systemData.screenSize }`);
     }
 
+    Object.values(systemData.featureFlags).forEach((ff) => {
+      params.push(`ff-` + `${ ff.param }=${ ff.value }`);
+    });
+
     return params.join('&');
   }
 }

package/utils/favicon.js

@@ -9,17 +9,17 @@ export function haveSetFavIcon() {
 
 export function setFavIcon(store) {
   const res = store.getters['management/byId'](MANAGEMENT.SETTING, SETTING.FAVICON);
-  const brandSetting = store.getters['management/byId'](MANAGEMENT.SETTING, SETTING.BRAND);
+  const brandSetting = store.getters['management/brand'];
   const link = findIconLink(document.head.getElementsByTagName('link'));
 
   if (link) {
     let brandImage;
 
-    if (brandSetting?.value === 'suse') {
+    if (brandSetting === 'suse') {
       brandImage = require('~shell/assets/brand/suse/favicon.png');
-    } else if (brandSetting?.value === 'csp') {
+    } else if (brandSetting === 'csp') {
       brandImage = require('~shell/assets/brand/csp/favicon.png');
-    } else if (brandSetting?.value === 'harvester') {
+    } else if (brandSetting === 'harvester') {
       brandImage = require('~shell/assets/brand/harvester/favicon.png');
     }
 

package/utils/pagination-wrapper.ts

@@ -19,7 +19,7 @@ interface Args {
   /**
    * Callback called when the resource is changed (notified by socket)
    */
-  onChange?: () => void,
+  onChange?: STEVE_WATCH_EVENT_LISTENER_CALLBACK,
 
   formatResponse?: {
     /**
@@ -72,13 +72,13 @@ class PaginationWrapper<T extends object> {
     this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters, $plugin: this.$store.$plugin }, enabledFor);
   }
 
-  async request(args: {
-      pagination: PaginationArgs,
+  async request({ pagination, forceWatch }: {
+    forceWatch?: boolean,
+    pagination: PaginationArgs,
   }): Promise<Result<T>> {
     if (!this.isEnabled) {
       throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ this.enabledFor.resource?.id }' in context '${ this.enabledFor.resource?.context }' not supported`);
     }
-    const { pagination } = args;
     const opt: ActionFindPageArgs = {
       watch:     false,
       pagination,
@@ -89,14 +89,18 @@ class PaginationWrapper<T extends object> {
     const out: ActionFindPageTransientResult<T> = await this.$store.dispatch(`${ this.enabledFor.store }/findPage`, { opt, type: this.enabledFor.resource?.id });
 
     // Watch
-    if (this.onChange && !this.steveWatchParams) {
+    const firstTime = !this.steveWatchParams;
+
+    if (this.onChange && (firstTime || forceWatch) ) { // && !this.steveWatchParams
       this.steveWatchParams = {
         event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
         id:     this.id,
         params: {
-          type: this.enabledFor.resource?.id as string,
-          mode: STEVE_WATCH_MODE.RESOURCE_CHANGES,
-        }
+          type:  this.enabledFor.resource?.id as string,
+          mode:  STEVE_WATCH_MODE.RESOURCE_CHANGES,
+          force: forceWatch,
+        },
+
       };
 
       this.watch();

package/utils/provider.ts

@@ -0,0 +1,14 @@
+import { IClusterProvisioner, ClusterProvisionerContext } from '@shell/core/types';
+
+export function getHostedProviders(context: ClusterProvisionerContext) {
+  return context?.$extension?.getProviders(context)?.filter((p: IClusterProvisioner) => p.group === 'hosted') || [];
+}
+
+export function isHostedProvider(context: ClusterProvisionerContext, provisioner: string) {
+  if (!provisioner) {
+    return false;
+  }
+  const provisioners = new Set(getHostedProviders(context).map((p: IClusterProvisioner) => p.id.toLowerCase()));
+
+  return provisioners.has(provisioner.toLowerCase());
+}

package/utils/selector-typed.ts

@@ -199,8 +199,12 @@ export function labelSelectorToSelector(labelSelector?: KubeLabelSelector): stri
   });
 
   (labelSelector?.matchExpressions || []).forEach((value: KubeLabelSelectorExpression) => {
-    if (value.operator === 'In' && value.values?.length === 1) {
-      res.push(`${ value.key }=${ value.values[0] }`);
+    if (value.operator === 'In' && value.values !== undefined) {
+      if (value.values?.length === 1) {
+        res.push(`${ value.key }=${ value.values[0] }`);
+      } else {
+        res.push(`${ value.key } in (${ value.values.join(',') })`);
+      }
     } else {
       throw new Error(`Unsupported matchExpression found when converting to selector string. ${ value }`);
     }

package/utils/version.js

@@ -74,6 +74,21 @@ export function isPrerelease(version = '') {
   return !!semver.prerelease(version);
 }
 
+export function isUpgradeFromPreToStable(currentVersion, targetVersion) {
+  if (!isPrerelease(currentVersion) || isPrerelease(targetVersion)) {
+    return false;
+  }
+
+  const cVersion = semver.clean(currentVersion, { loose: true });
+  const tVersion = semver.clean(targetVersion, { loose: true });
+
+  if (cVersion && tVersion && semver.valid(cVersion) && semver.valid(tVersion)) {
+    return semver.lt(cVersion, tVersion);
+  }
+
+  return false;
+}
+
 export function isDevBuild(version) {
   if ( ['dev', 'master', 'head'].includes(version) || version.endsWith('-head') || version.match(/-rc\d+$/) || version.match(/-alpha\d+$/) ) {
     return true;

package/plugins/nuxt-client-init.js

@@ -1,3 +0,0 @@
-export default async(context) => {
-  await context.store.dispatch('nuxtClientInit', context);
-};