@rancher/shell 1.2.3 → 2.0.1

package/plugins/steve/actions.js

@@ -1,14 +1,14 @@
 import https from 'https';
 import { addParam, parse as parseUrl, stringify as unParseUrl } from '@shell/utils/url';
 import { handleSpoofedRequest, loadSchemas } from '@shell/plugins/dashboard-store/actions';
-import { set } from '@shell/utils/object';
+import { dropKeys, set } from '@shell/utils/object';
 import { deferred } from '@shell/utils/promise';
 import { streamJson, streamingSupported } from '@shell/utils/stream';
 import isObject from 'lodash/isObject';
 import { classify } from '@shell/plugins/dashboard-store/classify';
 import { NAMESPACE } from '@shell/config/types';
-import jsyaml from 'js-yaml';
 import { handleKubeApiHeaderWarnings } from '@shell/plugins/steve/header-warnings';
+import { steveCleanForDownload } from '@shell/plugins/steve/resource-utils';
 
 export default {
 
@@ -19,7 +19,6 @@ export default {
 
   async request({ state, dispatch, rootGetters }, pOpt ) {
     const opt = pOpt.opt || pOpt;
-
     const spoofedRes = await handleSpoofedRequest(rootGetters, 'cluster', opt);
 
     if (spoofedRes) {
@@ -330,31 +329,7 @@ export default {
 
   // remove fields added by steve before showing/downloading yamls
   cleanForDownload(ctx, yaml) {
-    if (!yaml) {
-      return;
-    }
-    const rootKeys = [
-      'id',
-      'links',
-      'type',
-      'actions'
-    ];
-    const metadataKeys = [
-      'fields',
-      'relationships',
-      'state',
-    ];
-    const conditionKeys = [
-      'error',
-      'transitioning',
-    ];
-    const obj = jsyaml.load(yaml);
-
-    dropKeys(obj, rootKeys);
-    dropKeys(obj?.metadata, metadataKeys);
-    (obj?.status?.conditions || []).forEach((condition) => dropKeys(condition, conditionKeys));
-
-    return jsyaml.dump(obj);
+    return steveCleanForDownload(yaml);
   }
 };
 
@@ -398,16 +373,6 @@ function dropUnderscores(obj) {
   }
 }
 
-function dropKeys(obj, keys) {
-  if ( !obj ) {
-    return;
-  }
-
-  for ( const k of keys ) {
-    delete obj[k];
-  }
-}
-
 function dropCattleKeys(obj) {
   if ( !obj ) {
     return;

package/plugins/steve/getters.js

@@ -8,8 +8,16 @@ import HybridModel, { cleanHybridResources } from './hybrid-class';
 import NormanModel from './norman-class';
 import { urlFor } from '@shell/plugins/dashboard-store/getters';
 import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
-import pAndNFiltering from '@shell/utils/projectAndNamespaceFiltering.utils';
+import pAndNFiltering from '@shell/plugins/steve/projectAndNamespaceFiltering.utils';
+import stevePaginationUtils from '@shell/plugins/steve/steve-pagination-utils';
 import { parse } from '@shell/utils/url';
+import { splitObjectPath } from '@shell/utils/string';
+import { parseType } from '@shell/models/schema';
+import {
+  STEVE_AGE_COL,
+  STEVE_ID_COL, STEVE_LIST_GROUPS, STEVE_NAMESPACE_COL, STEVE_STATE_COL
+} from '@shell/config/pagination-table-headers';
+import { createHeaders } from '@shell/store/type-map.utils';
 
 export const STEVE_MODEL_TYPES = {
   NORMAN:  'norman',
@@ -24,54 +32,88 @@ const GC_IGNORE_TYPES = {
   [UI.NAV_LINK]: true,
 };
 
+// Include calls to /v1 AND /k8s/clusters/<cluster id>/v1
+const steveRegEx = new RegExp('(/v1)|(\/k8s\/clusters\/[a-z0-9-]+\/v1)');
+
 export default {
-  urlOptions: () => (url, opt) => {
+  urlOptions: () => (url, opt, schema) => {
     opt = opt || {};
     const parsedUrl = parse(url);
-    const isSteve = parsedUrl.path.startsWith('/v1');
+    const isSteve = steveRegEx.test(parsedUrl.path);
 
-    // labelSelector
-    if ( opt.labelSelector ) {
-      url += `${ url.includes('?') ? '&' : '?' }labelSelector=${ opt.labelSelector }`;
-    }
-    // End: labelSelector
+    const stevePagination = stevePaginationUtils.createParamsForPagination(schema, opt);
+
+    if (stevePagination) {
+      url += `${ (url.includes('?') ? '&' : '?') + stevePagination }`;
+    } else {
+      // labelSelector
+      if ( opt.labelSelector ) {
+        url += `${ url.includes('?') ? '&' : '?' }labelSelector=${ opt.labelSelector }`;
+      }
+      // End: labelSelector
 
-    // Filter
-    if ( opt.filter ) {
-      url += `${ (url.includes('?') ? '&' : '?') }`;
-      const keys = Object.keys(opt.filter);
+      // Filter
+      if ( opt.filter ) {
+        url += `${ (url.includes('?') ? '&' : '?') }`;
+        const keys = Object.keys(opt.filter);
 
-      keys.forEach((key) => {
-        let vals = opt.filter[key];
+        keys.forEach((key) => {
+          let vals = opt.filter[key];
 
-        if ( !isArray(vals) ) {
-          vals = [vals];
-        }
+          if ( !isArray(vals) ) {
+            vals = [vals];
+          }
 
-        // Steve's filter options now support more complex filtering not yet implemented here #9341
-        if (isSteve) {
-          url += `${ (url.includes('filter=') ? '&' : 'filter=') }`;
-        }
+          // Steve's filter options now support more complex filtering not yet implemented here #9341
+          if (isSteve) {
+            url += `${ (url.includes('filter=') ? '&' : 'filter=') }`;
+          }
 
-        const filterStrings = vals.map((val) => {
-          return `${ encodeURI(key) }=${ encodeURI(val) }`;
+          const filterStrings = vals.map((val) => {
+            return `${ encodeURI(key) }=${ encodeURI(val) }`;
+          });
+          const urlEnding = url.charAt(url.length - 1);
+          const nextStringConnector = ['&', '?', '='].includes(urlEnding) ? '' : '&';
+
+          url += `${ nextStringConnector }${ filterStrings.join('&') }`;
         });
-        const urlEnding = url.charAt(url.length - 1);
-        const nextStringConnector = ['&', '?', '='].includes(urlEnding) ? '' : '&';
+      }
 
-        url += `${ nextStringConnector }${ filterStrings.join('&') }`;
-      });
-    }
+      // `opt.namespaced` is either
+      // - a string representing a single namespace - add restriction to the url
+      // - an array of namespaces or projects - add restriction as a param
+      const namespaceProjectFilter = pAndNFiltering.checkAndCreateParam(opt);
 
-    // `opt.namespaced` is either
-    // - a string representing a single namespace - add restriction to the url
-    // - an array of namespaces or projects - add restriction as a param
-    const namespaceProjectFilter = pAndNFiltering.checkAndCreateParam(opt);
+      if (namespaceProjectFilter) {
+        url += `${ (url.includes('?') ? '&' : '?') + namespaceProjectFilter }`;
+      }
+      // End: Filter
 
-    if (namespaceProjectFilter) {
-      url += `${ (url.includes('?') ? '&' : '?') + namespaceProjectFilter }`;
+      // Limit
+      const limit = opt.limit;
+
+      if ( limit ) {
+        url += `${ url.includes('?') ? '&' : '?' }limit=${ limit }`;
+      }
+      // End: Limit
+
+      // Sort
+      // Steve's sort options supports multi-column sorting and column specific sort orders, not implemented yet #9341
+      const sortBy = opt.sortBy;
+      const orderBy = opt.sortOrder;
+
+      if ( sortBy ) {
+        if (isSteve) {
+          url += `${ url.includes('?') ? '&' : '?' }sort=${ (orderBy === 'desc' ? '-' : '') + encodeURI(sortBy) }`;
+        } else {
+          url += `${ url.includes('?') ? '&' : '?' }sort=${ encodeURI(sortBy) }`;
+          if ( orderBy ) {
+            url += `${ url.includes('?') ? '&' : '?' }order=${ encodeURI(orderBy) }`;
+          }
+        }
+      }
+      // End: Sort
     }
-    // End: Filter
 
     // Exclude
     // excludeFields should be an array of strings representing the paths of the fields to exclude
@@ -88,32 +130,6 @@ export default {
     }
     // End: Exclude
 
-    // Limit
-    const limit = opt.limit;
-
-    if ( limit ) {
-      url += `${ url.includes('?') ? '&' : '?' }limit=${ limit }`;
-    }
-    // End: Limit
-
-    // Sort
-    // Steve's sort options supports multi-column sorting and column specific sort orders, not implemented yet #9341
-    const sortBy = opt.sortBy;
-    const orderBy = opt.sortOrder;
-
-    if ( sortBy ) {
-      if (isSteve) {
-        url += `${ url.includes('?') ? '&' : '?' }sort=${ (orderBy === 'desc' ? '-' : '') + encodeURI(sortBy) }`;
-      } else {
-        url += `${ url.includes('?') ? '&' : '?' }sort=${ encodeURI(sortBy) }`;
-        if ( orderBy ) {
-          url += `${ url.includes('?') ? '&' : '?' }order=${ encodeURI(orderBy) }`;
-        }
-      }
-    }
-
-    // End: Sort
-
     return url;
   },
 
@@ -234,4 +250,91 @@ export default {
     return cache.generation;
   },
 
+  /**
+   * Checks the norman or steve schema resourceFields for the given path
+   */
+  pathExistsInSchema: (state, getters) => (type, path) => {
+    const schema = getters.schemaFor(type);
+
+    if (schema.requiresResourceFields && !schema.hasResourceFields) {
+      console.warn(`pathExistsInSchema requires schema ${ schema.id } to have resources fields via schema definition but none were found. has the schema 'fetchResourceFields' been called?`); // eslint-disable-line no-console
+
+      return false;
+    }
+
+    const schemaDefinitions = schema.requiresResourceFields ? schema.schemaDefinitions : null;
+    const parts = splitObjectPath(path);
+    let schemaOrSchemaDefinition = schema;
+
+    // Iterate down the parts (properties) until there are no parts left (success) or the path cannot be found (failure)
+    while ( parts.length ) {
+      const key = parts.shift();
+
+      const field = schemaOrSchemaDefinition.resourceFields?.[key];
+
+      type = field?.type;
+
+      if ( !type ) {
+        return false;
+      }
+
+      if ( parts.length ) {
+        type = parseType(type, field).pop(); // Get the main part of array[map[something]] => something
+
+        schemaOrSchemaDefinition = schemaDefinitions ? schemaDefinitions?.[type] : getters.schemaFor(type);
+
+        if ( !schema ) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  },
+
+  /*
+   * Override the vanilla type-map headersFor. This allows custom columns
+   */
+  headersFor: (state, getters, rootState, rootGetters) => ({
+    getters: typeMapGetters,
+    state: typeMapState,
+  }, { schema, pagination }) => {
+    if (!pagination ) {
+      return;
+    }
+
+    return createHeaders({
+      state: typeMapState, getters: typeMapGetters, rootGetters
+    }, {
+      headers:     typeMapState.paginationHeaders,
+      typeOptions: typeMapGetters['optionsFor'](schema, true),
+      schema,
+      columns:     {
+        state:     STEVE_STATE_COL,
+        namespace: STEVE_NAMESPACE_COL,
+        age:       STEVE_AGE_COL,
+        id:        STEVE_ID_COL
+      }
+    });
+  },
+
+  /**
+   * Override the vanilla type-map optionsFor. This allows custom list values
+   */
+  optionsFor: () => (ctx, { schema, pagination, opts }) => {
+    if (pagination) {
+      // As headers are hardcoded each list should have specific default sort option
+      // This avoids the sortable table adding both name and id (which when combined with group would result in 3 sort args, which isn't supported)
+      const steveOpts = { listMandatorySort: [] };
+
+      if (!opts.listGroupsWillOverride && schema.attributes.namespaced) {
+        // There's no pre-configured settings... and we're paginating... so use pagination specific groups
+        steveOpts.listGroups = STEVE_LIST_GROUPS;
+        steveOpts.listGroupsWillOverride = true;
+      }
+
+      return steveOpts;
+    }
+  },
+
 };

package/plugins/steve/hybrid-class.js

@@ -1,4 +1,4 @@
-import { ANNOTATIONS_TO_IGNORE_REGEX, LABELS_TO_IGNORE_REGEX } from '@shell/config/labels-annotations';
+import { ANNOTATIONS_TO_IGNORE_REGEX, LABELS_TO_IGNORE_REGEX, DESCRIPTION } from '@shell/config/labels-annotations';
 import omitBy from 'lodash/omitBy';
 import pickBy from 'lodash/pickBy';
 import Vue from 'vue';
@@ -100,4 +100,8 @@ export default class HybridModel extends Resource {
   get state() {
     return this.stateObj?.name || 'unknown';
   }
+
+  get description() {
+    return this.metadata?.annotations?.[DESCRIPTION] || this.spec?.description || this._description;
+  }
 }

package/plugins/steve/mutations.js

@@ -7,11 +7,13 @@ import {
   load,
   remove,
   batchChanges,
-  replace
+  replace,
+  loadAdd
 } from '@shell/plugins/dashboard-store/mutations';
 import { perfLoadAll } from '@shell/plugins/steve/performanceTesting';
 import Vue from 'vue';
 import { classify } from '@shell/plugins/dashboard-store/classify';
+import SteveSchema from '@shell/models/steve-schema';
 
 function registerNamespace(state, namespace) {
   let cache = state.podsByNamespace[namespace];
@@ -121,7 +123,8 @@ export default {
     ctx,
     skipHaveAll,
     namespace,
-    revision
+    revision,
+    pagination
   }) {
     // Performance testing in dev and when env var is set
     if (process.env.dev && !!process.env.perfTest) {
@@ -129,7 +132,7 @@ export default {
     }
 
     const proxies = loadAll(state, {
-      type, data, ctx, skipHaveAll, namespace, revision
+      type, data, ctx, skipHaveAll, namespace, revision, pagination
     });
 
     // If we loaded a set of pods, then update the podsByNamespace cache
@@ -159,13 +162,21 @@ export default {
   },
 
   reset(state) {
+    // Reset generic store things.... then steve specific things
+
     resetStore(state, this.commit);
+
     this.commit(`${ state.config.namespace }/resetSubscriptions`);
 
     // Clear the podsByNamespace cache
     state.podsByNamespace = {};
+
+    SteveSchema.reset(state.config.namespace);
   },
 
+  /**
+  * Load multiple different types of resources
+  */
   loadMulti(state, { data, ctx }) {
     for (const entry of data) {
       const resource = load(state, { data: entry, ctx });
@@ -179,6 +190,16 @@ export default {
     }
   },
 
+  loadAdd(state, { type, data: allLatest, ctx }) {
+    loadAdd(state, {
+      type, data: allLatest, ctx
+    });
+
+    if (allLatest.length && allLatest[0].type === POD) {
+      updatePodsByNamespaceCache(state, ctx, allLatest, false);
+    }
+  },
+
   remove(state, obj) {
     remove(state, obj, this.getters);
 

package/plugins/steve/norman-class.js

@@ -1,8 +1,34 @@
 import { ANNOTATIONS_TO_IGNORE_REGEX, LABELS_TO_IGNORE_REGEX } from '@shell/config/labels-annotations';
 import pickBy from 'lodash/pickBy';
 import Vue from 'vue';
-import { matchesSomeRegex } from '@shell/utils/string';
-import Resource from '@shell/plugins/dashboard-store/resource-class';
+import { findBy } from '@shell/utils/array';
+import { matchesSomeRegex, coerceStringTypeToScalarType } from '@shell/utils/string';
+import Resource, { DNS_LIKE_TYPES } from '@shell/plugins/dashboard-store/resource-class';
+import { get } from '@shell/utils/object';
+import {
+  displayKeyFor,
+  validateBoolean,
+  validateChars,
+  validateDnsLikeTypes,
+  validateLength,
+} from '@shell/utils/validators';
+import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
+import isString from 'lodash/isString';
+import uniq from 'lodash/uniq';
+
+import isEmpty from 'lodash/isEmpty';
+
+const STRING_LIKE_TYPES = [
+  'string',
+  'date',
+  'blob',
+  'enum',
+  'multiline',
+  'masked',
+  'password',
+  'dnsLabel',
+  'hostname',
+];
 
 export default class NormanModel extends Resource {
   setLabels(val) {
@@ -56,4 +82,118 @@ export default class NormanModel extends Resource {
       Vue.set(this, key, { ...spec[key] });
     });
   }
+
+  isCondition(condition, withStatus = 'True') {
+    if ( !this.conditions ) {
+      return false;
+    }
+
+    const entry = findBy((this.conditions || []), 'type', condition);
+
+    if ( !entry ) {
+      return false;
+    }
+
+    if ( !withStatus ) {
+      return true;
+    }
+
+    return (entry.status || '').toLowerCase() === `${ withStatus }`.toLowerCase();
+  }
+
+  /**
+   * Check this instance is valid against
+   * - the schema's resource fields
+   * - also calls super.validationErrors
+   */
+  validationErrors(data = this, opt = { ignoreFields: undefined }) {
+    const errors = [];
+    const {
+      type: originalType,
+      schema
+    } = data;
+    const type = normalizeType(originalType);
+
+    if ( !originalType ) {
+      // eslint-disable-next-line
+      console.warn(this.t('validation.noType'), data);
+
+      return errors;
+    }
+
+    if ( !schema ) {
+      // eslint-disable-next-line
+      // console.warn(this.t('validation.noSchema'), originalType, data);
+
+      return errors;
+    }
+
+    const fields = schema.resourceFields || {};
+    const keys = Object.keys(fields);
+    let field, key, val, displayKey;
+
+    for ( let i = 0 ; i < keys.length ; i++ ) {
+      const fieldErrors = [];
+
+      key = keys[i];
+      field = fields[key];
+      val = get(data, key);
+      displayKey = displayKeyFor(type, key, this.$rootGetters);
+
+      const fieldType = field?.type ? normalizeType(field.type) : null;
+      const valIsString = isString(val);
+
+      if ( opt.ignoreFields && opt.ignoreFields.includes(key) ) {
+        continue;
+      }
+
+      if ( val === undefined ) {
+        val = null;
+      }
+
+      if (valIsString) {
+        if (fieldType) {
+          Vue.set(data, key, coerceStringTypeToScalarType(val, fieldType));
+        }
+
+        // Empty strings on nullable string fields -> null
+        if ( field.nullable && val.length === 0 && STRING_LIKE_TYPES.includes(fieldType)) {
+          val = null;
+
+          Vue.set(data, key, val);
+        }
+      }
+      if (fieldType === 'boolean') {
+        validateBoolean(val, field, displayKey, this.$rootGetters, fieldErrors);
+      } else {
+        validateLength(val, field, displayKey, this.$rootGetters, fieldErrors);
+        validateChars(val, field, displayKey, this.$rootGetters, fieldErrors);
+      }
+
+      if (fieldErrors.length > 0) {
+        fieldErrors.push(this.t('validation.required', { key: displayKey }));
+        errors.push(...fieldErrors);
+        continue;
+      }
+
+      // IDs claim to be these but are lies...
+      if ( key !== 'id' && !isEmpty(val) && DNS_LIKE_TYPES.includes(fieldType) ) {
+        // DNS types should be lowercase
+        const tolower = (val || '').toLowerCase();
+
+        if ( tolower !== val ) {
+          val = tolower;
+
+          Vue.set(data, key, val);
+        }
+
+        fieldErrors.push(...validateDnsLikeTypes(val, fieldType, displayKey, this.$rootGetters, fieldErrors));
+      }
+      errors.push(...fieldErrors);
+    }
+
+    const rootErrors = super.validationErrors(this, opt);
+
+    return uniq([...errors, ...rootErrors]);
+  }
 }

package/{utils → plugins/steve}/projectAndNamespaceFiltering.utils.ts

@@ -1,7 +1,6 @@
 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[]}
+import { ActionFindAllArgs } from '@shell/types/store/dashboard-store.types';
 
 class ProjectAndNamespaceFiltering {
   static param = 'projectsornamespaces'
@@ -9,7 +8,7 @@ class ProjectAndNamespaceFiltering {
   /**
    * Does the request `opt` definition require resources are fetched from a specific set namespaces/projects?
    */
-  isApplicable(opt: Opt): boolean {
+  isApplicable(opt: ActionFindAllArgs): boolean {
     return Array.isArray(opt.namespaced);
   }
 
@@ -37,7 +36,7 @@ class ProjectAndNamespaceFiltering {
   /**
    * Check if `opt` requires resources from specific ns/projects, if so return the required query param (x=y)
    */
-  checkAndCreateParam(opt: Opt): string {
+  checkAndCreateParam(opt: ActionFindAllArgs): string {
     if (!this.isApplicable(opt)) {
       return '';
     }
@@ -45,17 +44,36 @@ class ProjectAndNamespaceFiltering {
     return this.createParam(opt.namespaced);
   }
 
-  private createParam(namespaceFilter: string[] | undefined): string {
+  public 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(',');
+    const namespaces = namespaceFilter.reduce((res, n) => {
+      const name = n
+        .replace(NAMESPACE_FILTER_NS_FULL_PREFIX, '')
+        .replace(NAMESPACE_FILTER_P_FULL_PREFIX, '');
+
+      if (name.startsWith('-')) {
+        res.exclude.push(n.substring(1, n.length));
+      } else {
+        res.include.push(name);
+      }
+
+      return res;
+    }, { include: [] as string[], exclude: [] as string[] });
+
+    let res = '';
+
+    if (namespaces.include.length) {
+      res = `${ ProjectAndNamespaceFiltering.param }=${ namespaces.include.join(',') }`;
+    }
+
+    if (namespaces.exclude.length) {
+      res = `${ ProjectAndNamespaceFiltering.param }!=${ namespaces.exclude.join(',') }`;
+    }
 
-    return `${ ProjectAndNamespaceFiltering.param }=${ projectsOrNamespaces }`;
+    return res;
   }
 }
 

package/plugins/steve/resource-utils.ts

@@ -0,0 +1,38 @@
+import { dropKeys } from '@shell/utils/object';
+import jsyaml from 'js-yaml';
+
+export function steveCleanForDownload(yaml: string, keys?: {
+  rootKeys?: string[],
+  metadataKeys?: string[],
+  conditionKeys?: string[]
+ }): string | undefined {
+  if (!yaml) {
+    return;
+  }
+
+  const {
+    rootKeys = [
+      'id',
+      'links',
+      'type',
+      'actions'
+    ],
+    metadataKeys = [
+      'fields',
+      'relationships',
+      'state',
+    ],
+    conditionKeys = [
+      'error',
+      'transitioning',
+    ]
+  } = keys || {};
+
+  const obj: any = jsyaml.load(yaml);
+
+  dropKeys(obj, rootKeys);
+  dropKeys(obj?.metadata, metadataKeys);
+  (obj?.status?.conditions || []).forEach((condition: any) => dropKeys(condition, conditionKeys));
+
+  return jsyaml.dump(obj);
+}