@rancher/shell 3.0.5-rc.6 → 3.0.5-rc.8

package/utils/__tests__/create-yaml.test.ts

@@ -488,3 +488,238 @@ __clone: true
     expect(actual).toStrictEqual(expected);
   });
 });
+
+describe('fx: createYaml', () => {
+  interface CommentFieldsOption {
+    path: string;
+    key: string;
+  }
+
+  const schemas = [
+    {
+      id:             'provisioning.cattle.io.cluster',
+      resourceFields: {
+        apiVersion: {
+          type:   'string',
+          create: false,
+          update: false
+        },
+        kind: {
+          type:   'string',
+          create: false,
+          update: false
+        },
+        metadata: {
+          type:   'io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta',
+          create: true,
+          update: true
+        },
+        spec: {
+          type:     'provisioning.cattle.io.v1.cluster.spec',
+          nullable: true,
+          create:   true,
+          update:   true
+        }
+      }
+    },
+    {
+      id:             'io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta',
+      resourceFields: {
+        annotations: {
+          type:   'map[string]',
+          create: true,
+          update: true
+        },
+        labels: {
+          type:   'map[string]',
+          create: true,
+          update: true
+        },
+        namespace: {
+          type:   'string',
+          create: true,
+          update: true
+        }
+      }
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec',
+      resourceFields: {
+        localClusterAuthEndpoint: {
+          type:     'provisioning.cattle.io.v1.cluster.spec.localClusterAuthEndpoint',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        rkeConfig: {
+          type:     'provisioning.cattle.io.v1.cluster.spec.rkeConfig',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        foo: {
+          type:     'array[string]',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+      }
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec.localClusterAuthEndpoint',
+      resourceFields: {
+        caCerts: {
+          type:     'string',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        enabled: {
+          type:     'boolean',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        fqdn: {
+          type:     'string',
+          nullable: true,
+          create:   true,
+          update:   true
+        }
+      }
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec.rkeConfig',
+      resourceFields: {
+        additionalManifest: {
+          type:     'string',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        chartValues: {
+          type:     'provisioning.cattle.io.v1.cluster.spec.rkeConfig.chartValues',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        machineGlobalConfig: {
+          type:     'provisioning.cattle.io.v1.cluster.spec.rkeConfig.machineGlobalConfig',
+          nullable: true,
+          create:   true,
+          update:   true
+        }
+      }
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec.rkeConfig.chartValues',
+      resourceFields: {}
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec.rkeConfig.machineGlobalConfig',
+      resourceFields: {}
+    }
+  ];
+
+  it('should comment out fields when specific properties are defined on the model with commentFieldsOptions', () => {
+    const obj = {
+      type:     'provisioning.cattle.io.cluster',
+      metadata: {
+        namespace:   'fleet-default',
+        annotations: { someannotation: 'test' },
+        labels:      {}
+      },
+      __clone: true,
+      spec:    {
+        localClusterAuthEndpoint: {
+          caCerts: '',
+          enabled: false,
+          fqdn:    ''
+        },
+        rkeConfig: {
+          machineGlobalConfig: {
+            cni:                   'calico',
+            'disable-kube-proxy':  false,
+            'etcd-expose-metrics': false,
+            profile:               null
+          },
+          chartValues: {}
+        },
+        foo: [
+          'bar',
+          'bar2'
+        ],
+      },
+      apiVersion: 'provisioning.cattle.io/v1',
+      kind:       'Cluster'
+    };
+
+    const objResult = {
+      metadata: {
+        namespace:   'fleet-default',
+        annotations: { someannotation: 'test' },
+        labels:      {}
+      },
+      __clone: true,
+      spec:    {
+        rkeConfig: {
+          machineGlobalConfig: {
+            cni:                   'calico',
+            'disable-kube-proxy':  false,
+            'etcd-expose-metrics': false,
+          },
+          chartValues: {}
+        },
+      },
+      apiVersion: 'provisioning.cattle.io/v1',
+      kind:       'Cluster'
+    };
+
+    const type = 'provisioning.cattle.io.cluster';
+    const commentFieldsOptions: CommentFieldsOption[] = [
+      { path: 'spec.rkeConfig.machineGlobalConfig', key: 'profile' },
+      { path: 'spec', key: 'localClusterAuthEndpoint' },
+      { path: 'spec', key: 'foo' },
+    ];
+
+    // Define the expected YAML output as a string, adjusted for correct spacing
+    const expectedYaml = `
+apiVersion: provisioning.cattle.io/v1
+kind: Cluster
+metadata:
+  annotations:
+    someannotation: test
+    #  key: string
+  labels:
+    {}
+    #  key: string
+  namespace: fleet-default
+spec:
+#  localClusterAuthEndpoint:
+#    caCerts: ''
+#    enabled: false
+#    fqdn: ''
+  rkeConfig:
+    chartValues:
+      {}
+    machineGlobalConfig:
+      cni: calico
+      disable-kube-proxy: false
+      etcd-expose-metrics: false
+#       profile: null
+#    additionalManifest: string
+#  foo:
+#    - bar
+#    - bar2
+#    - string
+__clone: true`.trim();
+
+    const result = createYaml(schemas, type, obj, true, 0, '', null, {}, commentFieldsOptions as any);
+
+    // Check if result is a valid YAML
+    expect(jsyaml.load(result.trim())).toStrictEqual(objResult);
+
+    // Check if properties are commented out
+    expect(result.trim()).toStrictEqual(expectedYaml);
+  });
+});

package/utils/__tests__/kontainer.test.ts

@@ -17,6 +17,25 @@ describe('fx: diffUpstreamSpec', () => {
     expect(diffUpstreamSpec(upstream, local)).toStrictEqual(diff);
   });
 
+  it.each([
+    [{
+      a: { one: 'a' },
+      b: ['1', 'b'],
+      c: 'c'
+    }, {
+      a: {},
+      b: [],
+      c: ''
+    }, {
+      a: {},
+      b: [],
+      c: ''
+    }],
+    [{ a: 'a' }, { b: null }, { }],
+  ])('should include fields that are empty objects, arrays or strings on the local object regardless of upstream definition', (upstream, local, diff) => {
+    expect(diffUpstreamSpec(upstream, local)).toStrictEqual(diff);
+  });
+
   it.each([
     [{ a: null }, { a: {} }, {}],
     [{ a: null }, { a: [] }, {}],

package/utils/__tests__/uiplugins.test.ts

@@ -0,0 +1,84 @@
+import type { Plugin, Version } from '@shell/types/uiplugins';
+import { getPluginChartVersion, getPluginChartVersionLabel } from '../uiplugins';
+
+function makePlugin(partial: Partial<Plugin>): Plugin {
+  return {
+    name:                   'test',
+    label:                  'Test',
+    description:            '',
+    id:                     'test',
+    versions:               [],
+    installed:              false,
+    builtin:                false,
+    experimental:           false,
+    certified:              false,
+    chart:                  {} as any,
+    incompatibilityMessage: '',
+    installableVersions:    [],
+    displayVersion:         '',
+    pluginVersionLabel:     '',
+    helmError:              false,
+    ...partial
+  };
+}
+
+describe('fx: getPluginChartVersion', () => {
+  it('returns the Helm Chart version when displayVersion matches appVersion', () => {
+    const plugin = makePlugin({
+      displayVersion: '1.2.3',
+      versions:       [
+        { appVersion: '1.2.3', version: '4.5.6' } as Version,
+        { appVersion: '2.0.0', version: '5.0.0' } as Version
+      ]
+    });
+
+    expect(getPluginChartVersion(plugin)).toBe('4.5.6');
+  });
+
+  it('falls back to version if appVersion is not present', () => {
+    const plugin = makePlugin({
+      displayVersion: '7.8.9',
+      versions:       [
+        { version: '7.8.9' } as Version,
+        { version: '8.0.0' } as Version
+      ]
+    });
+
+    expect(getPluginChartVersion(plugin)).toBe('7.8.9');
+  });
+
+  it('returns displayVersion if no matching chart is found', () => {
+    const plugin = makePlugin({
+      displayVersion: '9.9.9',
+      versions:       [
+        { appVersion: '1.0.0', version: '1.0.0' } as Version,
+        { appVersion: '2.0.0', version: '2.0.0' } as Version
+      ]
+    });
+
+    expect(getPluginChartVersion(plugin)).toBe('9.9.9');
+  });
+
+  it('returns undefined if plugin is undefined', () => {
+    expect(getPluginChartVersion(undefined)).toBeUndefined();
+  });
+
+  it('returns displayVersion if plugin.versions is undefined', () => {
+    const plugin = makePlugin({ displayVersion: '1.0.0', versions: undefined as any });
+
+    expect(getPluginChartVersion(plugin)).toBe('1.0.0');
+  });
+});
+
+describe('fx: getPluginChartVersionLabel', () => {
+  it('returns simple version string if Helm Chart Version appVersion matches version', () => {
+    const version = { version: '1.2.3', appVersion: '1.2.3' } as Version;
+
+    expect(getPluginChartVersionLabel(version)).toBe('1.2.3');
+  });
+  it(`if version and appVersion don't match, it returns 'appVersion (version)' string`, () => {
+    const version = { version: '1.2.3', appVersion: '4.5.6' } as Version;
+
+    expect(getPluginChartVersionLabel(version)).toBe('4.5.6 (1.2.3)');
+  });
+});

package/utils/back-off.ts

@@ -0,0 +1,176 @@
+type BackOffEntry = {
+  timeoutId?: NodeJS.Timeout,
+  try: number,
+  retries: number,
+  description: string,
+  metadata: any,
+}
+
+/**
+ * Helper class which handles backing off making the supplied request
+ *
+ * see `execute` for more info
+ */
+class BackOff {
+  private map: {
+   [id: string]: BackOffEntry
+  } = {};
+
+  private log(level: 'error' | 'info' | 'debug', id: string, classDescription: string, description: string, ...args: any[]) {
+    console[level](`BackOff... Id: "${ id }". Description: "${ description }"\nStatus: ${ classDescription }\n`, ...args); // eslint-disable-line no-console
+  }
+
+  /**
+   * Get a specific back off process
+   */
+  getBackOff(id: string): BackOffEntry {
+    return this.map[id];
+  }
+
+  /**
+   * Stop ALL back off processes started since the ui was loaded
+   */
+  resetAll() {
+    Object.keys(this.map).forEach((id) => {
+      this.reset(id);
+    });
+  }
+
+  /**
+   * Stop all back off process with a specific prefix
+   */
+  resetPrefix(prefix:string) {
+    Object.keys(this.map).forEach((id) => {
+      if (id.startsWith(prefix)) {
+        this.reset(id);
+      }
+    });
+  }
+
+  /**
+   * Stop a back off process with a specific id
+   */
+  reset(id: string) {
+    const backOff: BackOffEntry = this.map[id];
+
+    if (backOff) {
+      if (backOff?.timeoutId) {
+        this.log('info', id, 'Stopping (cancelling active back-off)', backOff.description);
+
+        clearTimeout(backOff.timeoutId);
+      }
+      this.log('debug', id, 'Reset', backOff.description);
+
+      delete this.map[id];
+    }
+  }
+
+  /**
+   * Call a function, but if it's recently been called delay execution aka back off
+   *
+   * This can be used in a totally disjoined asynchronous way
+   *
+   * 1. Request function A to be run
+   * 2. Entirely separate process requests function A to be run again
+   * 3. Back off process waits Xms and then runs function A again
+   * 4. Repeat steps 2 and 3, with an exponential increasing delay
+   *
+   * This can be called repeatedly, if the previous delay is still running new requests will be ignored
+   */
+  async execute<T = any>({
+    id, description, retries = 10, delayedFn, canFn = async() => true, metadata
+  }: {
+    /**
+     * Unique id for the execution of this function.
+     *
+     * This will be used to delay further executions, and also to cancel it
+     */
+    id: string,
+    /**
+     * Basic text description to use in logging
+     */
+    description: string,
+    /**
+     * Number of executions allowed before flatly refusing to call more. Defaults to 10
+     */
+    retries?: number,
+    /**
+     * Before calling delayedFn check if it can still run
+     *
+     * Useful for checking state after a looong delay
+     */
+    canFn?: () => Promise<boolean>,
+    /**
+     * Call this function
+     * - if it's not already waiting to run
+     * - if it's passed canFn
+     * - if it hasn't been tried over `retries` amount
+     *
+     * The function will be increasingly (exponentially) delayed if it has previously been called
+     */
+    delayedFn: () => Promise<any>,
+    /**
+     * Anything that might be important outside of this file (used with `getBackOff`)
+     */
+    metadata?: T,
+  }): Promise<NodeJS.Timeout | undefined> {
+    const backOff: BackOffEntry = this.map[id];
+
+    const cont = await canFn();
+
+    if (!cont) {
+      this.log('info', id, 'Skipping (can execute fn test failed)', description);
+
+      return undefined;
+    } else if (backOff?.timeoutId) {
+      this.log('info', id, 'Skipping (previous back off process still running)', description);
+
+      return backOff.timeoutId;
+    } else {
+      const backOffTry = backOff?.try || 0;
+
+      if (backOffTry + 1 > retries) {
+        this.log('error', id, 'Aborting (too many retries)', description);
+
+        return undefined;
+      }
+
+      // 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
+      const delay = backOffTry === 0 ? 1 : Math.pow(backOffTry, 2) * 250;
+
+      this.log('info', id, `Delaying call (attempt ${ backOffTry + 1 }, delayed by ${ delay }ms)`, description);
+
+      const timeout = setTimeout(async() => {
+        try {
+          this.log('info', id, `Executing call`, description);
+
+          await delayedFn();
+        } catch (e) {
+          // Error occurred. Don't clear the map. Next time this is called we'll back off before trying ...
+          this.log('error', id, 'Failed call', description, e);
+        }
+
+        // Unblock future calls
+        delete this.map[id]?.timeoutId;
+      }, delay);
+
+      this.map[id] = {
+        timeoutId: timeout,
+        try:       backOff?.try ? backOff.try + 1 : 1,
+        retries,
+        description,
+        metadata
+      };
+
+      return timeout;
+    }
+  }
+}
+
+const backOff = new BackOff();
+
+export default backOff;

package/utils/create-yaml.js

@@ -70,13 +70,14 @@ export const ACTIVELY_REMOVE = [
 
 const INDENT = 2;
 
-export function createYamlWithOptions(schemas, type, data, options) {
+export function createYamlWithOptions(schemas, type, data, options, commentFieldsOptions) {
   return createYaml(
     schemas,
     type,
     data,
     true, 0, '', null,
-    options
+    options,
+    commentFieldsOptions
   );
 }
 
@@ -89,6 +90,7 @@ export function createYaml(
   path = '',
   rootType = null,
   dataOptions = {},
+  commentFieldsOptions = null
 ) {
   data = data || {};
 
@@ -133,6 +135,10 @@ export function createYaml(
 
   const regularFields = [];
 
+  if ( !commentFieldsOptions ) {
+    commentFieldsOptions = data?.commentFieldsOptions;
+  }
+
   if (processAlwaysAdd) {
     // Add all the parents of each key so that spec.template.foo.blah
     // causes 'spec', 'template' and 'foo' keys to be created
@@ -230,6 +236,18 @@ export function createYaml(
       out = 'type:';
     }
 
+    commentFieldsOptions = addCommentSubFieldsOptions(commentFieldsOptions, data, path, key);
+
+    // If commentFieldOptions is defined on the model and the currentPath matches the path and key
+    // defined in one of the options, then comment out that line.
+    if ( Array.isArray(commentFieldsOptions) && commentFieldsOptions.length ) {
+      const currentPath = path ? `${ path }.${ key }` : key;
+
+      if ( commentFieldsOptions.some((option) => `${ option.path }.${ option.key }` === currentPath) ) {
+        out = `#${ out }`;
+      }
+    }
+
     // if a key on data is not listed in the schema's resourceFields, just convert it to yaml, add indents where needed, and return
     if ( !field ) {
       if (data[key]) {
@@ -275,7 +293,7 @@ export function createYaml(
         out += `#  key: ${ mapOf }`;
       } else {
         // If not a simple type ie some sort of object/array, recursively build out commented fields (note data = null here) per the type's (mapOf's) schema
-        const chunk = createYaml(schemas, mapOf, null, processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions);
+        const chunk = createYaml(schemas, mapOf, null, processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions, commentFieldsOptions);
         let indented = indent(chunk);
 
         // convert "#    foo" to "#foo"
@@ -296,7 +314,34 @@ export function createYaml(
           if ( cleaned?.[key] ) {
             const parsedData = jsyaml.dump(cleaned[key]);
 
-            out += `\n${ indent(parsedData.trim()) }`;
+            let chunk;
+
+            // If commentFieldOptions is defined on the model and the array has the property (`key`)
+            // defined in one of the options, then comment out that line.
+            if ( Array.isArray(commentFieldsOptions) && commentFieldsOptions.length ) {
+              let lines = parsedData.split('\n');
+
+              commentFieldsOptions.forEach((option) => {
+                // Assuming the path for the current array matches the option's path
+                // and the specific key to comment out exists in the array
+                if ( `${ path }.${ key }` === option.path && data[key][option.key] !== undefined ) {
+                  // Comment out the line containing the target line
+                  lines = lines.map((line, i) => {
+                    if ( i === Number(option.key) ) {
+                      return `#${ line }`;
+                    }
+
+                    return line;
+                  });
+                }
+              });
+
+              chunk = lines.join('\n').trim();
+            } else {
+              chunk = parsedData.trim();
+            }
+
+            out += `\n${ indent(chunk) }`;
           }
         } catch (e) {
           console.error(`Error: Unable to parse array data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
@@ -306,7 +351,7 @@ export function createYaml(
       if ( SIMPLE_TYPES.includes(arrayOf) ) {
         out += `\n#  - ${ arrayOf }`;
       } else {
-        const chunk = createYaml(schemas, arrayOf, null, false, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions);
+        const chunk = createYaml(schemas, arrayOf, null, false, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions, commentFieldsOptions);
         let indented = indent(chunk, 2);
 
         // turn "#        foo" into "#  - foo"
@@ -357,19 +402,45 @@ export function createYaml(
 
     const subDef = schemaDefinitions?.[type] || findBy(schemas, 'id', type);
 
-    if ( subDef) {
+    if ( subDef ) {
       let chunk;
 
       if (subDef?.resourceFields && !isEmpty(subDef?.resourceFields)) {
-        chunk = createYaml(schemas, type, data[key], processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions);
+        chunk = createYaml(schemas, type, data[key], processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions, commentFieldsOptions);
       } else if (data[key]) {
         // if there are no fields defined on the schema but there are in the data, just format data as yaml and add to output yaml
         try {
           const parsed = jsyaml.dump(data[key]);
 
-          chunk = parsed.trim();
+          // If commentFieldOptions is defined on the model and `data[key]` has the property (`key`)
+          // defined in one of the options, then comment out that line.
+          if ( Array.isArray(commentFieldsOptions) && commentFieldsOptions.length ) {
+            let lines = parsed.split('\n');
+
+            commentFieldsOptions.forEach((option) => {
+              // Assuming the path for the current data[key] matches the option's path
+              // and the specific key to comment out exists in the data[key]
+              if ( `${ path }.${ key }` === option.path && data[key][option.key] !== undefined ) {
+                const targetKeyString = `${ option.key }:`;
+
+                // Comment out the line containing the target key
+                lines = lines.map((line) => {
+                  if ( line.trim().startsWith(targetKeyString) ) {
+                    return `# ${ line }`;
+                  }
+
+                  return line;
+                });
+              }
+            });
+
+            chunk = lines.join('\n').trim();
+          } else {
+            // If commentFieldsOptions do not exist, use the original `parsed` string
+            chunk = parsed.trim();
+          }
         } catch (e) {
-          console.error(`Error: Unale to parse data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
+          console.error(`Error: Unable to parse data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
         }
       }
 
@@ -380,6 +451,29 @@ export function createYaml(
 
     return out;
   }
+
+  /**
+   * Extends original commentFieldsOptions to cover nested objects
+   */
+  function addCommentSubFieldsOptions(options, data, path, key) {
+    if (!!options) {
+      if ( Array.isArray(options) && options.length ) {
+        const currentPath = path ? `${ path }.${ key }` : key;
+
+        if ( options.some((option) => `${ option.path }.${ option.key }` === currentPath) ) {
+          options = [
+            ...options,
+            ...Object.keys(data[key]).map((k) => ({
+              path: `${ path }.${ key }`,
+              key:  k
+            }))
+          ];
+        }
+      }
+    }
+
+    return options;
+  }
 }
 
 function comment(lines) {