@rancher/shell 0.3.8 → 0.3.10

package/store/type-map.js

@@ -971,7 +971,7 @@ export const getters = {
 
   groupByFor(state) {
     return (schema) => {
-      return state.groupBy[schema.id];
+      return state.groupBy[schema?.id];
     };
   },
 

package/types/shell/index.d.ts

@@ -1738,6 +1738,7 @@ export namespace MANAGEMENT {
     const GLOBAL_ROLE_BINDING_1: string;
     export { GLOBAL_ROLE_BINDING_1 as GLOBAL_ROLE_BINDING };
     export const POD_SECURITY_POLICY_TEMPLATE: string;
+    export const PSP_TEMPLATE_BINDING: string;
     export const PSA: string;
     export const MANAGED_CHART: string;
     export const USER_NOTIFICATION: string;
@@ -1840,6 +1841,7 @@ export namespace HCI {
     export const IMAGE: string;
     const SETTING_1: string;
     export { SETTING_1 as SETTING };
+    export const HARVESTER_CONFIG: string;
 }
 export const VIRTUAL_HARVESTER_PROVIDER: "harvester";
 export namespace ADDRESSES {
@@ -2491,10 +2493,33 @@ export default _default;
 // @shell/utils/create-yaml
 
 declare module '@shell/utils/create-yaml' {
-export function createYaml(schemas: any, type: any, data: any, processAlwaysAdd?: boolean, depth?: number, path?: string, rootType?: any): string;
+export function createYamlWithOptions(schemas: any, type: any, data: any, options: any): string;
+export function createYaml(schemas: any, type: any, data: any, processAlwaysAdd?: boolean, depth?: number, path?: string, rootType?: any, dataOptions?: {}): string;
+export function getBlockDescriptor(value: any, key: any): {
+    header: string;
+    indentation: string;
+};
 export function typeRef(type: any, str: any): any;
 export function typeMunge(type: any): any;
 export function saferDump(obj: any): any;
+/**
+ * Handles newlines indicators in the multiline blocks.
+ *
+ * this is required since jsyaml.dump doesn't support chomping and scalar style at the moment.
+ * see: https://github.com/nodeca/js-yaml/issues/171
+ *
+ * @param {*} data the multiline block
+ * @param {*} options blocks indicators, see: https://yaml-multiline.info
+ *
+ * - scalarStyle:
+ *     one of '|', '>'
+ *     default '|'
+ * - chomping:
+ *     one of: null, '', '-', '+'
+ *     default: null
+ * @returns the result of jsyaml.dump with the addition of multiline indicators
+ */
+export function dumpBlock(data: any, options?: any): any;
 export const SIMPLE_TYPES: string[];
 export const NEVER_ADD: string[];
 export const ACTIVELY_REMOVE: string[];
@@ -2655,14 +2680,24 @@ export function haveV1MonitoringWorkloads(store: any): Promise<boolean>;
 // @shell/utils/namespace-filter
 
 declare module '@shell/utils/namespace-filter' {
-export const NAMESPACE_FILTER_SPECIAL: "special";
+export const NAMESPACE_FILTER_ALL_PREFIX: "all";
+export const NAMESPACE_FILTER_NS_PREFIX: "ns";
+export const NAMESPACE_FILTER_P_PREFIX: "project";
+export const NAMESPACE_FILTER_NS_FULL_PREFIX: string;
+export const NAMESPACE_FILTER_P_FULL_PREFIX: string;
 export const NAMESPACE_FILTER_ALL: "all";
-export const NAMESPACE_FILTER_ALL_SYSTEM: "all://system";
-export const NAMESPACE_FILTER_ALL_USER: "all://user";
-export const NAMESPACE_FILTER_ALL_ORPHANS: "all://orphans";
+export const NAMESPACE_FILTER_ALL_SYSTEM: string;
+export const NAMESPACE_FILTER_ALL_USER: string;
+export const NAMESPACE_FILTER_ALL_ORPHANS: string;
 export const NAMESPACE_FILTER_NAMESPACED_PREFIX: "namespaced://";
 export const NAMESPACE_FILTER_NAMESPACED_YES: "namespaced://true";
 export const NAMESPACE_FILTER_NAMESPACED_NO: "namespaced://false";
+export namespace NAMESPACE_FILTER_KINDS {
+    const DIVIDER: string;
+    const PROJECT: string;
+    const NAMESPACE: string;
+    const SPECIAL: string;
+}
 export function createNamespaceFilterKey(clusterId: any, product: any): any;
 export function createNamespaceFilterKeyWithId(clusterId: any, productId: any): string;
 export function splitNamespaceFilterKey(key: any): {
@@ -2926,8 +2961,8 @@ export function simplify(matchExpressionsInput: any): {
     matchLabels: {};
     matchExpressions: any[];
 };
-export function matches(obj: any, selector: any): boolean;
-export function matching(ary: any, selector: any): any;
+export function matches(obj: any, selector: any, labelKey?: string): boolean;
+export function matching(ary: any, selector: any, labelKey: any): any;
 }
 
 // @shell/utils/socket

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

@@ -0,0 +1,63 @@
+import {
+  getBlockDescriptor,
+  dumpBlock,
+} from '@shell/utils/create-yaml';
+
+const key = 'example';
+const randomData = '\n      foo\n      bar\n';
+
+const scalarStyles = ['>', '|'];
+const chomping = ['+', '-', ''];
+const indentations = ['4', '2', ''];
+
+describe('fx: getBlockDescriptor', () => {
+  describe('should parse blocks header for all block indicators combo', () => {
+    scalarStyles.forEach((scalar) => {
+      chomping.forEach((chomping) => {
+        indentations.forEach((indentation) => {
+          const combo = `${ scalar }${ indentation }${ chomping }`;
+
+          it(`combo: ${ combo }`, () => {
+            const toParse = `${ key }: ${ combo }${ randomData }`;
+
+            const desc = getBlockDescriptor(toParse, key);
+
+            expect(desc?.header).toBe(`${ key }: ${ combo }`);
+            expect(desc?.indentation).toBe(indentation);
+          });
+        });
+      });
+    });
+  });
+});
+
+describe('fx: dumpBlock', () => {
+  describe('should create a data block replacing indicators with blocks indicator from options', () => {
+    const key = 'example';
+
+    scalarStyles.forEach((scalarStyle) => {
+      chomping.forEach((chomping) => {
+        const options = {
+          [key]: {
+            chomping,
+            scalarStyle
+          }
+        };
+
+        it(`options: { scalarStyle: ${ scalarStyle }, chomping: ${ chomping } } with indentation`, () => {
+          const data = { [key]: ' foo  \n bar   \n   \n   foo\n   bar\n   ' };
+          const block = dumpBlock(data, options);
+
+          expect(block.includes(`example: ${ scalarStyle }${ chomping }2`)).toBeTruthy();
+        });
+
+        it(`options: { scalarStyle: ${ scalarStyle }, chomping: ${ chomping } } without indentation`, () => {
+          const data = { [key]: 'foo  \nbar   \n\nfoo\nbar\n   ' };
+          const block = dumpBlock(data, options);
+
+          expect(block.includes(`example: ${ scalarStyle }${ chomping }`)).toBeTruthy();
+        });
+      });
+    });
+  });
+});

package/utils/array.ts

@@ -188,6 +188,10 @@ export function uniq<T>(ary: T[]): T[] {
   return out;
 }
 
+export function concatStrings(a: string[], b: string[]) {
+  return [...a.map(aa => b.map(bb => aa.concat(bb)))].reduce((acc, arr) => [...arr, ...acc], []);
+}
+
 interface KubeResource { metadata: { labels: { [name: string]: string} } } // Migrate to central kube types resource when those are brought in
 export function getUniqueLabelKeys<T extends KubeResource>(aryResources: T[]): string[] {
   const uniqueObj = aryResources.reduce((res, r) => {

package/utils/create-yaml.js

@@ -65,7 +65,26 @@ export const ACTIVELY_REMOVE = [
 
 const INDENT = 2;
 
-export function createYaml(schemas, type, data, processAlwaysAdd = true, depth = 0, path = '', rootType = null) {
+export function createYamlWithOptions(schemas, type, data, options) {
+  return createYaml(
+    schemas,
+    type,
+    data,
+    true, 0, '', null,
+    options
+  );
+}
+
+export function createYaml(
+  schemas,
+  type,
+  data,
+  processAlwaysAdd = true,
+  depth = 0,
+  path = '',
+  rootType = null,
+  dataOptions = {}
+) {
   const schema = findBy(schemas, 'id', type);
 
   if ( !rootType ) {
@@ -220,25 +239,25 @@ export function createYaml(schemas, type, data, processAlwaysAdd = true, depth =
       if (data[key]) {
         try {
           const cleaned = cleanUp(data);
-          const parsedData = jsyaml.dump(cleaned[key]);
+          const parsedData = dumpBlock(cleaned[key], dataOptions[key]);
 
-          out += `\n${ indent(parsedData.trim()) }`;
+          out += `\n${ indent(parsedData) }`;
         } catch (e) {
           console.error(`Error: Unable to parse map data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
         }
       }
 
       if ( SIMPLE_TYPES.includes(mapOf) ) {
-        out += `\n#  key: ${ mapOf }`;
+        out += `#  key: ${ mapOf }`;
       } else {
         // If not a simple type ie some sort of object/array, recusively 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);
+        const chunk = createYaml(schemas, mapOf, null, processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions);
         let indented = indent(chunk);
 
         // convert "#    foo" to "#foo"
         indented = indented.replace(/^(#)?\s\s\s\s/, '$1');
 
-        out += `\n${ indented }`;
+        out += `${ indented }`;
       }
 
       return out;
@@ -263,7 +282,7 @@ export function createYaml(schemas, type, data, processAlwaysAdd = true, depth =
       if ( SIMPLE_TYPES.includes(arrayOf) ) {
         out += `\n#  - ${ arrayOf }`;
       } else {
-        const chunk = createYaml(schemas, arrayOf, null, false, depth + 1, (path ? `${ path }.${ key }` : key), rootType);
+        const chunk = createYaml(schemas, arrayOf, null, false, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions);
         let indented = indent(chunk, 2);
 
         // turn "#        foo" into "#  - foo"
@@ -318,7 +337,7 @@ export function createYaml(schemas, type, data, processAlwaysAdd = true, depth =
       let chunk;
 
       if (subDef?.resourceFields && !isEmpty(subDef?.resourceFields)) {
-        chunk = createYaml(schemas, type, data[key], processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType);
+        chunk = createYaml(schemas, type, data[key], processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions);
       } 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 {
@@ -351,6 +370,43 @@ function serializeSimpleValue(data) {
   return jsyaml.dump(data).trim();
 }
 
+export function getBlockDescriptor(value, key) {
+  const header = getBlockHeader(value, key);
+
+  return {
+    header,
+    indentation: getBlockIndentation(header),
+  };
+}
+
+/**
+ *
+ * @param {string} value the block of text to be parsed
+ * @param {*} blockKey the key of the block
+ * @returns the key + the block scalar indicators, see https://yaml-multiline.info - Block Scalars
+ */
+function getBlockHeader(value, blockKey) {
+  const card = `(${ blockKey })[\\:][\\s|\\t]+[\\|\\>][\\d]*[\\-\\+]?`;
+  const re = new RegExp(card, 'gi');
+
+  const found = value.match(re);
+
+  return found?.[0] || '';
+}
+
+/**
+ *
+ * @param {string} blockHeader the key + the block scalar indicators
+ * @returns the indentation indicator from the block header, see https://yaml-multiline.info - Indentation
+ */
+function getBlockIndentation(blockHeader) {
+  const blockScalars = blockHeader.substr(blockHeader.indexOf(':') + 1);
+
+  const indentation = blockScalars.match(/\d+/);
+
+  return indentation?.[0] || '';
+}
+
 export function typeRef(type, str) {
   const re = new RegExp(`^${ type }\\[(.*)\\]$`);
   const match = str.match(re);
@@ -381,3 +437,44 @@ export function saferDump(obj) {
 
   return out;
 }
+
+/**
+ * Handles newlines indicators in the multiline blocks.
+ *
+ * this is required since jsyaml.dump doesn't support chomping and scalar style at the moment.
+ * see: https://github.com/nodeca/js-yaml/issues/171
+ *
+ * @param {*} data the multiline block
+ * @param {*} options blocks indicators, see: https://yaml-multiline.info
+ *
+ * - scalarStyle:
+ *     one of '|', '>'
+ *     default '|'
+ * - chomping:
+ *     one of: null, '', '-', '+'
+ *     default: null
+ * @returns the result of jsyaml.dump with the addition of multiline indicators
+ */
+export function dumpBlock(data, options = {}) {
+  const parsed = jsyaml.dump(data);
+
+  let out = parsed;
+
+  const blockFields = Object.keys(data).filter(k => data[k].includes('\n'));
+
+  if (blockFields.length) {
+    for (const key of blockFields) {
+      const { header, indentation } = getBlockDescriptor(out, key);
+
+      const scalarStyle = options[key]?.scalarStyle ?? '|';
+      const chomping = options[key]?.chomping ?? '';
+
+      /**
+       * Replace the original block indicators with the ones provided in the options param
+       */
+      out = out.replace(header, `${ key }: ${ scalarStyle }${ chomping }${ indentation }`);
+    }
+  }
+
+  return out;
+}

package/utils/namespace-filter.js

@@ -1,13 +1,25 @@
-export const NAMESPACE_FILTER_SPECIAL = 'special';
+export const NAMESPACE_FILTER_ALL_PREFIX = 'all';
+export const NAMESPACE_FILTER_NS_PREFIX = 'ns';
+export const NAMESPACE_FILTER_P_PREFIX = 'project';
 
-export const NAMESPACE_FILTER_ALL = 'all';
-export const NAMESPACE_FILTER_ALL_SYSTEM = 'all://system';
-export const NAMESPACE_FILTER_ALL_USER = 'all://user';
-export const NAMESPACE_FILTER_ALL_ORPHANS = 'all://orphans';
+export const NAMESPACE_FILTER_NS_FULL_PREFIX = `${ NAMESPACE_FILTER_NS_PREFIX }://`;
+export const NAMESPACE_FILTER_P_FULL_PREFIX = `${ NAMESPACE_FILTER_P_PREFIX }://`;
+
+export const NAMESPACE_FILTER_ALL = NAMESPACE_FILTER_ALL_PREFIX;
+export const NAMESPACE_FILTER_ALL_SYSTEM = `${ NAMESPACE_FILTER_ALL_PREFIX }://system`;
+export const NAMESPACE_FILTER_ALL_USER = `${ NAMESPACE_FILTER_ALL_PREFIX }://user`;
+export const NAMESPACE_FILTER_ALL_ORPHANS = `${ NAMESPACE_FILTER_ALL_PREFIX }://orphans`;
 export const NAMESPACE_FILTER_NAMESPACED_PREFIX = 'namespaced://';
 export const NAMESPACE_FILTER_NAMESPACED_YES = 'namespaced://true';
 export const NAMESPACE_FILTER_NAMESPACED_NO = 'namespaced://false';
 
+export const NAMESPACE_FILTER_KINDS = {
+  DIVIDER:   'divider',
+  PROJECT:   'project',
+  NAMESPACE: 'namespace',
+  SPECIAL:   'special'
+};
+
 const SEPARATOR = '__%%__';
 
 export const createNamespaceFilterKey = (clusterId, product) => {

package/utils/projectAndNamespaceFiltering.utils.ts

@@ -0,0 +1,62 @@
+import { NAMESPACE_FILTER_NS_FULL_PREFIX, NAMESPACE_FILTER_P_FULL_PREFIX } from '@shell/utils/namespace-filter';
+import { getPerformanceSetting } from '@shell/utils/settings';
+
+type Opt = { [key: string]: any, namespaced?: string[]}
+
+class ProjectAndNamespaceFiltering {
+  static param = 'projectsornamespaces'
+
+  /**
+   * Does the request `opt` definition require resources are fetched from a specific set namespaces/projects?
+   */
+  isApplicable(opt: Opt): boolean {
+    return Array.isArray(opt.namespaced);
+  }
+
+  isEnabled(rootGetters: any): boolean {
+    const currentProduct = rootGetters['currentProduct'];
+
+    // Only enable for the cluster store at the moment. In theory this should work in management as well, as they're both 'steve' stores
+    if (currentProduct?.inStore !== 'cluster') {
+      return false;
+    }
+
+    if (currentProduct?.showWorkspaceSwitcher) {
+      return false;
+    }
+
+    const perfConfig = getPerformanceSetting(rootGetters);
+
+    if (!perfConfig.forceNsFilterV2?.enabled) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Check if `opt` requires resources from specific ns/projects, if so return the required query param (x=y)
+   */
+  checkAndCreateParam(opt: Opt): string {
+    if (!this.isApplicable(opt)) {
+      return '';
+    }
+
+    return this.createParam(opt.namespaced);
+  }
+
+  private createParam(namespaceFilter: string[] | undefined): string {
+    if (!namespaceFilter || !namespaceFilter.length) {
+      return '';
+    }
+
+    const projectsOrNamespaces = namespaceFilter
+      .map(f => f.replace(NAMESPACE_FILTER_NS_FULL_PREFIX, '')
+        .replace(NAMESPACE_FILTER_P_FULL_PREFIX, ''))
+      .join(',');
+
+    return `${ ProjectAndNamespaceFiltering.param }=${ projectsOrNamespaces }`;
+  }
+}
+
+export default new ProjectAndNamespaceFiltering();

package/utils/selector.js

@@ -1,4 +1,5 @@
 import { isArray, addObject, findBy } from '@shell/utils/array';
+import { get } from '@shell/utils/object';
 
 const parseCache = {};
 
@@ -121,7 +122,7 @@ export function convert(matchLabelsObj, matchExpressions) {
       out.push({
         key,
         operator: 'In',
-        values:   [value],
+        values:   isArray(value) ? value : [value],
       });
     }
   }
@@ -162,7 +163,7 @@ export function simplify(matchExpressionsInput) {
   return { matchLabels, matchExpressions };
 }
 
-export function matches(obj, selector) {
+export function matches(obj, selector, labelKey = 'metadata.labels') {
   let rules = [];
 
   if ( typeof selector === 'string' ) {
@@ -178,7 +179,7 @@ export function matches(obj, selector) {
     return false;
   }
 
-  const labels = obj?.metadata?.labels || {};
+  const labels = get(obj, labelKey) || {};
 
   for ( const rule of rules ) {
     const value = labels[rule.key];
@@ -222,6 +223,6 @@ export function matches(obj, selector) {
   return true;
 }
 
-export function matching(ary, selector) {
-  return ary.filter(obj => matches(obj, selector));
+export function matching(ary, selector, labelKey) {
+  return ary.filter(obj => matches(obj, selector, labelKey));
 }

package/utils/settings.ts

@@ -22,6 +22,18 @@ export const fetchOrCreateSetting = async(store: Store<any>, id: string, val: st
   return setting;
 };
 
+/**
+  * Fetch a specific setting that might not exist
+  * We fetch all settings - reality is Rancher will have done this already, so there's no overhead in doing
+  * this - but if we fetch a specific setting that does not exist, we will get a 404, which we don't want
+  */
+export const fetchSetting = async(store: Store<any>, id: string) => {
+  const all = await store.dispatch('management/findAll', { type: MANAGEMENT.SETTING });
+  const setting = (all || []).find((setting: any) => setting.id === id);
+
+  return setting;
+};
+
 export const setSetting = async(store: Store<any>, id: string, val: string): Promise<any> => {
   const setting = await fetchOrCreateSetting(store, id, val, false);
 
@@ -32,19 +44,17 @@ export const setSetting = async(store: Store<any>, id: string, val: string): Pro
 };
 
 export const getPerformanceSetting = (rootGetters: Record<string, (arg0: string, arg1: string) => any>) => {
-  const perfSetting = rootGetters['management/byId'](MANAGEMENT.SETTING, SETTING.UI_PERFORMANCE);
-  let perfConfig = {};
+  const perfSettingResource = rootGetters['management/byId'](MANAGEMENT.SETTING, SETTING.UI_PERFORMANCE);
+  let perfSetting = {};
 
-  if (perfSetting && perfSetting.value) {
+  if (perfSettingResource?.value) {
     try {
-      perfConfig = JSON.parse(perfSetting.value);
+      perfSetting = JSON.parse(perfSettingResource.value);
     } catch (e) {
       console.warn('ui-performance setting contains invalid data'); // eslint-disable-line no-console
     }
   }
 
   // Start with the default and overwrite the values from the setting - ensures we have defaults for newly added options
-  perfConfig = Object.assign(DEFAULT_PERF_SETTING, perfConfig);
-
-  return perfConfig;
+  return Object.assign(DEFAULT_PERF_SETTING, perfSetting || {});
 };

package/vue.config.js

@@ -408,8 +408,8 @@ module.exports = function(dir, _appConfig) {
         }),
       }));
 
-      // The static assets need to be in the built public folder in order to get served (primarily the favicon for now)
-      config.plugins.push(new CopyWebpackPlugin([{ from: path.join(SHELL_ABS, 'static'), to: 'public' }]));
+      // The static assets need to be in the built assets directory in order to get served (primarily the favicon)
+      config.plugins.push(new CopyWebpackPlugin([{ from: path.join(SHELL_ABS, 'static'), to: '.' }]));
 
       config.resolve.extensions.push(...['.tsx', '.ts', '.js', '.vue', '.scss']);
       config.watchOptions = config.watchOptions || {};

package/models/k8s.cni.cncf.io.networkattachmentdefinition.js

@@ -1,93 +0,0 @@
-import Vue from 'vue';
-import SteveModel from '@shell/plugins/steve/steve-class';
-import { HCI } from '@shell/config/labels-annotations';
-
-export default class NetworkAttachmentDef extends SteveModel {
-  get _availableActions() {
-    let out = super._availableActions;
-    const toFilter = ['goToClone', 'cloneYaml', 'goToViewConfig', 'goToEditYaml', 'goToEdit'];
-
-    out = out.filter((action) => {
-      if (!toFilter.includes(action.action)) {
-        return action;
-      }
-    });
-
-    return out;
-  }
-
-  applyDefaults() {
-    const spec = this.spec || {
-      config: JSON.stringify({
-        cniVersion:  '0.3.1',
-        name:        '',
-        type:        'bridge',
-        bridge:      'harvester-br0',
-        promiscMode: true,
-        vlan:        '',
-        ipam:        {}
-      })
-    };
-
-    Vue.set(this, 'spec', spec);
-  }
-
-  get parseConfig() {
-    try {
-      return JSON.parse(this.spec.config) || {};
-    } catch (err) {
-      return {};
-    }
-  }
-
-  get isIpamStatic() {
-    return this.parseConfig.ipam?.type === 'static';
-  }
-
-  get vlanType() {
-    const type = this.parseConfig.type;
-
-    return type === 'bridge' ? 'L2VlanNetwork' : type;
-  }
-
-  get vlanId() {
-    return this.parseConfig.vlan;
-  }
-
-  get customValidationRules() {
-    const rules = [
-      {
-        nullable:       false,
-        path:           'metadata.name',
-        required:       true,
-        minLength:      1,
-        maxLength:      63,
-        translationKey: 'harvester.fields.name'
-      }
-    ];
-
-    return rules;
-  }
-
-  get connectivity() {
-    const annotations = this.metadata?.annotations || {};
-    const route = annotations[HCI.NETWORK_ROUTE];
-    let config = {};
-
-    try {
-      config = JSON.parse(route || '{}');
-    } catch {
-      return 'invalid';
-    }
-
-    const connectivity = config.connectivity;
-
-    if (connectivity === 'false') {
-      return 'inactive';
-    } else if (connectivity === 'true') {
-      return 'active';
-    } else {
-      return connectivity;
-    }
-  }
-}