@rancher/shell 0.5.3 → 2.0.0

package/plugins/steve/__tests__/utils/mutation.test.helpers.ts

@@ -0,0 +1,105 @@
+import { POD } from '@shell/config/types';
+import Resource from '@shell/plugins/dashboard-store/resource-class';
+
+const createCtx = () => ({
+  rootGetters: { 'type-map/optionsFor': (type: string) => ({}) },
+  getters:     {
+    classify:        (resource: any) => Resource,
+    cleanResource:   (existing: Resource, resource: any) => resource,
+    keyFieldForType: () => 'id',
+  }
+});
+
+const create = (type: string) => ({
+  id: '1',
+  type,
+});
+
+const createResource = (type: string, props = {}) => new Resource({
+  ...create(type),
+  ...props
+});
+
+const createPod = () => create(POD);
+
+const createPodResource = (props = {}) => createResource(POD, props);
+
+const createCache = (props: any) => ({
+  generation:    0,
+  haveAll:       false,
+  haveNamespace: undefined,
+  havePage:      undefined,
+  haveSelector:  {},
+  list:          [],
+  loadCounter:   0,
+  revision:      0,
+  map:           new Map(),
+  ...props
+});
+
+const createNoOp = () => {
+  const emptyState = { types: {} };
+
+  return {
+    params: [emptyState, {
+      ctx:   createCtx(),
+      batch: { }
+    }],
+    expected: { state: emptyState }
+  };
+};
+
+const loadAllCreateNoOp = () => {
+  const emptyState = { types: {} };
+
+  return {
+    params: [
+      emptyState,
+      {
+        ctx:  createCtx(),
+        type: POD,
+        data: [],
+      }],
+    expected: { state: emptyState }
+  };
+};
+
+const loadAllCreateNewEntry = () => {
+  const pod = createPodResource({ namespace: 'namespace' } );
+
+  return {
+    params: [
+      { types: { [POD]: createCache({}) } },
+      {
+        ctx:  createCtx(),
+        type: POD,
+        data: [pod]
+      }
+    ],
+    expected: {
+      types: {
+        [POD]: createCache({
+          generation: 1,
+          list:       [new Resource(pod)],
+          map:        new Map([
+            [pod.id, new Resource(pod)]
+          ])
+        })
+      },
+      podsByNamespace: {},
+    }
+  };
+};
+
+export default {
+  createCtx,
+  createCache,
+  createNoOp,
+  createResource,
+  createPod,
+  createPodResource,
+  loadAll: {
+    createNewEntry: loadAllCreateNewEntry,
+    createNoOp:     loadAllCreateNoOp
+  }
+};

package/plugins/steve/accept-or-reject-socket-message.ts

@@ -0,0 +1,103 @@
+import pAndNFiltering from '@shell/plugins/steve/projectAndNamespaceFiltering.utils';
+
+type TypeIsCached = { [type: string]: boolean }
+
+/**
+ * There are scenarios where we can't subscribe to subsets of a resource type
+ * - Multiple namespaces or projects
+ * - Result of Pagination (a single page of resources that have been sorted / filtered)
+ *
+ * For those scenarios we subscribe to allll changes BUT ignore changes that are not applicable to that subset
+ */
+class AcceptOrRejectSocketMessage {
+  typeIsNamespaced({ getters }: any, type: string): boolean {
+    return getters.haveNamespace(type)?.length > 0;
+  }
+
+  typeIsPaginated({ getters }: any, type: string): boolean {
+    return !!getters.havePage(type);
+  }
+
+  filteredNamespaces({ rootGetters }: any) {
+    // Note - activeNamespaceCache should be accurate for both namespace/project filtering and pagination namespace/project filtering
+    return rootGetters.activeNamespaceCache;
+  }
+
+  /**
+   * Note - namespace can be a list of projects or namespaces
+   */
+  subscribeNamespace(namespace: string[]) {
+    if (pAndNFiltering.isApplicable({ namespaced: namespace, type: 'n/a' }) && namespace.length) {
+      return undefined; // AKA sub to everything
+    }
+
+    return namespace;
+  }
+
+  validChange({ getters, rootGetters }: any, type: string, data: any) {
+    // If the resource is in namespace outside of the one's we have selected in the header... ignore the change
+    if (this.typeIsNamespaced({ getters }, type)) {
+      const namespaces = this.filteredNamespaces({ rootGetters });
+
+      if (!namespaces[data.metadata.namespace]) {
+        return false;
+      }
+    }
+
+    // If the resource does not meet the previously fetched paginated resource... ignore the change
+    if (this.typeIsPaginated({ getters }, type)) {
+      const page = getters['all'](type);
+
+      return !!page.find((pR: any) => pR.id === data.id);
+    }
+
+    return true;
+  }
+
+  validateBatchChange({ getters, rootGetters }: any, batch: { [key: string]: any}) {
+    const namespaces = this.filteredNamespaces({ rootGetters });
+
+    const typeIs: { namespaced: TypeIsCached, paginated: TypeIsCached} = {
+      namespaced: {},
+      paginated:  {},
+    };
+
+    Object.entries(batch).forEach(([type, entries]) => {
+      if (typeIs.namespaced[type] === undefined) {
+        typeIs.namespaced[type] = this.typeIsNamespaced({ getters }, type);
+      }
+      if (typeIs.namespaced[type]) {
+        const schema = getters.schemaFor(type);
+
+        if (!schema?.attributes?.namespaced) {
+          return;
+        }
+
+        Object.keys(entries).forEach((id) => {
+          const namespace = id.split('/')[0];
+
+          if (!namespace || !namespaces[namespace]) {
+            delete entries[id];
+          }
+        });
+      }
+
+      if (typeIs.paginated[type] === undefined) {
+        typeIs.paginated[type] = this.typeIsPaginated({ getters }, type);
+      }
+      if (typeIs.paginated[type]) {
+        const page = getters['all'](type);
+
+        Object.keys(entries).forEach((id) => {
+          if (!page.find((pR: any) => pR.id === id)) {
+            delete entries[id];
+          }
+        });
+      }
+    });
+
+    return batch;
+  }
+}
+
+export default new AcceptOrRejectSocketMessage();

package/plugins/steve/actions.js

@@ -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) {

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',
@@ -28,53 +36,84 @@ const GC_IGNORE_TYPES = {
 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 = steveRegEx.test(parsedUrl.path);
 
-    // labelSelector
-    if ( opt.labelSelector ) {
-      url += `${ url.includes('?') ? '&' : '?' }labelSelector=${ opt.labelSelector }`;
-    }
-    // End: labelSelector
+    const stevePagination = stevePaginationUtils.createParamsForPagination(schema, opt);
 
-    // Filter
-    if ( opt.filter ) {
-      url += `${ (url.includes('?') ? '&' : '?') }`;
-      const keys = Object.keys(opt.filter);
+    if (stevePagination) {
+      url += `${ (url.includes('?') ? '&' : '?') + stevePagination }`;
+    } else {
+      // labelSelector
+      if ( opt.labelSelector ) {
+        url += `${ url.includes('?') ? '&' : '?' }labelSelector=${ opt.labelSelector }`;
+      }
+      // End: labelSelector
 
-      keys.forEach((key) => {
-        let vals = opt.filter[key];
+      // Filter
+      if ( opt.filter ) {
+        url += `${ (url.includes('?') ? '&' : '?') }`;
+        const keys = Object.keys(opt.filter);
 
-        if ( !isArray(vals) ) {
-          vals = [vals];
-        }
+        keys.forEach((key) => {
+          let vals = opt.filter[key];
 
-        // Steve's filter options now support more complex filtering not yet implemented here #9341
-        if (isSteve) {
-          url += `${ (url.includes('filter=') ? '&' : 'filter=') }`;
-        }
+          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=') }`;
+          }
 
-        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
+
+      // 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 (namespaceProjectFilter) {
-      url += `${ (url.includes('?') ? '&' : '?') + namespaceProjectFilter }`;
+      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
@@ -91,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;
   },
 
@@ -126,10 +139,30 @@ export default {
     // `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
-    if (opt?.namespaced && !pAndNFiltering.isApplicable(opt)) {
-      const parts = url.split('/');
+    if (!opt?.url && opt?.namespaced && !pAndNFiltering.isApplicable(opt)) {
+      // Update path to include `namespace`, but take into account
+      // - if there is an id
+      // - if there are query params
 
-      url = `${ parts.join('/') }/${ opt.namespaced }`;
+      // Construct a url so query params / fragments are avoided
+      const urlObj = new URL(url);
+      const path = urlObj.pathname;
+
+      if (!!path?.length && path[path.length - 1] === '/') {
+        urlObj.pathname = path.substring(0, path.length - 1);
+      }
+      const parts = urlObj.pathname.split('/');
+
+      if (id) {
+        // namespace should go before the id in the path
+        parts.splice(parts.length - 1, 0, opt.namespaced);
+        urlObj.pathname = parts.join('/');
+      } else {
+        // namespace should go at the end of the path
+        urlObj.pathname = `${ urlObj.pathname.split('/').join('/') }/${ opt.namespaced }`;
+      }
+
+      url = urlObj.toString();
     }
 
     return url;
@@ -217,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,12 +7,13 @@ import {
   load,
   remove,
   batchChanges,
-  replace
+  replace,
+  loadAdd
 } from '@shell/plugins/dashboard-store/mutations';
-import { keyForSubscribe } from '@shell/plugins/steve/resourceWatcher';
 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];
@@ -122,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) {
@@ -130,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
@@ -151,18 +153,30 @@ export default {
 
   forgetType(state, type) {
     if ( forgetType(state, type) ) {
-      delete state.inError[keyForSubscribe({ type })];
+      Object.keys(state.inError).forEach((key) => {
+        if (key.startsWith(type)) {
+          delete state.inError[key];
+        }
+      });
     }
   },
 
   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 });
@@ -176,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);