dashboard-shell-shell 3.0.2-rc.105 → 3.0.5-test.1

package/plugins/dashboard-store/actions.js

@@ -7,8 +7,11 @@ import { classify } from '@shell/plugins/dashboard-store/classify';
 import { normalizeType } from './normalize';
 import garbageCollect from '@shell/utils/gc/gc';
 import { addSchemaIndexFields } from '@shell/plugins/steve/schema.utils';
-import { addParam } from '@shell/utils/url';
+import { addParam, parse } from '@shell/utils/url';
 import { conditionalDepaginate } from '@shell/store/type-map.utils';
+import { STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
+import { FilterArgs } from '@shell/types/store/pagination.types';
+import { isLabelSelectorEmpty, labelSelectorToSelector } from '@shell/utils/selector-typed';
 
 export const _ALL = 'all';
 export const _MERGE = 'merge';
@@ -76,6 +79,29 @@ const findAllGetter = (getters, type, opt) => {
   return opt.namespaced ? getters.matching(type, null, opt.namespaced, { skipSelector: true }) : getters.all(type);
 };
 
+const createFindWatchArg = ({
+  type, id, opt, res
+}) => {
+  const revision = typeof opt.revision !== 'undefined' ? opt.revision : res?.metadata?.resourceVersion;
+  const watchMsg = {
+    type,
+    id,
+    // Although not used by sockets, we need this for when resyncWatch calls find... which needs namespace to construct the url
+    namespace: opt.namespaced,
+    revision:  revision || '',
+    force:     opt.forceWatch === true,
+  };
+
+  const idx = id.indexOf('/');
+
+  if ( idx > 0 ) {
+    watchMsg.namespace = id.substr(0, idx);
+    watchMsg.id = id.substr(idx + 1);
+  }
+
+  return watchMsg;
+};
+
 export default {
   request() {
     throw new Error('Not Implemented');
@@ -83,9 +109,17 @@ export default {
 
   loadSchemas,
 
-  // Load a page of data for a given type
-  // Used for incremental loading when enabled
-  async loadDataPage(ctx, { type, opt }) {
+  /**
+   * Load a page of data for a given type. Given the response will continue until there are no pages left to fetch
+   *
+   * Used for incremental loading when enabled
+   *
+   * If we're in the non-vai world paginate via native limit/next (pageByLimit)
+   * If we're in the vai world paginate via page number (pageByNumber)
+   */
+  async loadDataPage(ctx, {
+    type, opt, pageByLimit, pageByNumber
+  }) {
     const { getters, commit, dispatch } = ctx;
 
     type = getters.normalizeType(type);
@@ -99,6 +133,17 @@ export default {
     const loadCount = getters['loadCounter'](type);
 
     try {
+      if (pageByLimit) {
+        opt.url = pageByLimit.next;
+      } else if (pageByNumber) {
+        const { url, page, pageSize } = pageByNumber;
+
+        opt.url = addParam(url, 'page', `${ page }`);
+        opt.url = addParam(opt.url, 'pagesize', `${ pageSize }`);
+      } else {
+        throw Error('loadDataPage requires either pageByLimit or pageByNumber');
+      }
+
       const res = await dispatch('request', { opt, type });
 
       const newLoadCount = getters['loadCounter'](type);
@@ -115,12 +160,19 @@ export default {
         data: res.data,
       });
 
-      if (res.pagination?.next) {
+      if (pageByLimit && res.pagination?.next) {
+        dispatch('loadDataPage', {
+          type,
+          opt,
+          pageByLimit: { next: res.pagination.next },
+        });
+      } else if (pageByNumber && pageByNumber.page !== pageByNumber.pages) {
         dispatch('loadDataPage', {
           type,
-          opt: {
-            ...opt,
-            url: res.pagination?.next
+          opt,
+          pageByNumber: {
+            ...pageByNumber,
+            page: pageByNumber.page + 1,
           }
         });
       } else {
@@ -155,7 +207,6 @@ export default {
 
     opt = opt || {};
     type = getters.normalizeType(type);
-
     if ( !getters.typeRegistered(type) ) {
       commit('registerType', type);
     }
@@ -193,6 +244,7 @@ export default {
 
     console.log(`Find All: [${ ctx.state.config.namespace }] ${ type }`); // eslint-disable-line no-console
     opt = opt || {};
+    opt.isCollection = true;
     opt.url = getters.urlFor(type, null, opt);
     opt.stream = opt.stream !== false && load !== _NONE;
     opt.depaginate = conditionalDepaginate(typeOptions?.depaginate, { ctx, args: { type, opt } });
@@ -200,10 +252,10 @@ export default {
     let skipHaveAll = false;
 
     // if it's incremental loading, we do two parallel requests
-    // on for a limit of 100, to quickly show data
+    // one for a limit of 100, to quickly show data
     // another one with 1st page of the subset of the resource we are fetching
     // the default is 4 pages, but it can be changed on mixin/resource-fetch.js
-    let pageFetchOpts;
+    let pageByLimit, pageByNumber;
 
     if (opt.incremental) {
       commit('incrementLoadCounter', type);
@@ -212,14 +264,23 @@ export default {
         dispatch('resource-fetch/updateManualRefreshIsLoading', true, { root: true });
       }
 
-      pageFetchOpts = {
-        ...opt,
-        url: addParam(opt.url, 'limit', `${ opt.incremental }`),
-      };
+      if (opt.incremental.pageByNumber && getters.isSteveCacheUrl(parse(opt.url).path)) {
+        // Set the configuration for the rest of the incremental requests
+        pageByNumber = {
+          url:      opt.url,
+          page:     1,
+          pages:    opt.incremental.increments,
+          pageSize: opt.incremental.resourcesPerIncrement,
+        };
+        // this is where we "hijack" the limit for the dispatch('request') some lines below and therefore have 2 initial requests in parallel
+        opt.url = addParam(opt.url, 'pagesize', `${ opt.incremental.quickLoadCount }`);
+      } else {
+        // Set the configuration for the rest of the incremental requests
+        pageByLimit = { next: addParam(opt.url, 'limit', `${ opt.incremental.resourcesPerIncrement }`) };
+        // this is where we "hijack" the limit for the dispatch('request') some lines below and therefore have 2 initial requests in parallel
+        opt.url = addParam(opt.url, 'limit', `${ opt.incremental.quickLoadCount }`);
+      }
 
-      // this is where we "hijack" the limit for the dispatch('request') some lines below
-      // and therefore have 2 initial requests in parallel
-      opt.url = addParam(opt.url, 'limit', '100');
       skipHaveAll = true;
 
       // since we are forcing a request, clear the haveAll
@@ -333,7 +394,9 @@ export default {
 
       if (opt.incremental) {
         // This needs to come after the loadAll (which resets state) so supplements via loadDataPage aren't lost
-        dispatch('loadDataPage', { type, opt: pageFetchOpts });
+        dispatch('loadDataPage', {
+          type, opt, pageByLimit, pageByNumber
+        });
       }
     }
 
@@ -362,13 +425,18 @@ export default {
   },
 
   /**
+   * If result not already cached, make a http request to fetch a specific set of resources
+   *
+   * This accepts all the new sql-cache backed api features (sort, filter, etc)
    *
    * @param {*} ctx
    * @param { {type: string, opt: ActionFindPageArgs} } opt
+   * @returns @ActionFindPageResponse
    */
   async findPage(ctx, { type, opt }) {
     const { getters, commit, dispatch } = ctx;
 
+    // of type @ActionFindPageArgs
     opt = opt || {};
 
     if (!opt.pagination) {
@@ -383,12 +451,24 @@ export default {
       commit('registerType', type);
     }
 
+    // of type @STEVE_WATCH_PARAMS
+    const watchArgs = {
+      type,
+      namespace: opt.watchNamespace || opt.namespaced, // it could be either apparently
+      force:     opt.forceWatch === true,
+      mode:      STEVE_WATCH_MODE.RESOURCE_CHANGES,
+    };
+
     // No need to request the resources if we have them already
     if (!opt.transient && !opt.force && getters['havePaginatedPage'](type, opt)) {
+      if (opt.watch !== false ) {
+        dispatch('watch', watchArgs);
+      }
+
       return findAllGetter(getters, type, opt);
     }
 
-    console.log(`Find Page: [${ ctx.state.config.namespace }] ${ type }. Page: ${ opt.pagination.page }. Size: ${ opt.pagination.pageSize }`); // eslint-disable-line no-console
+    console.log(`Find Page: [${ ctx.state.config.namespace }] ${ type }. Page: ${ opt.pagination.page }. Size: ${ opt.pagination.pageSize }. Sort: ${ opt.pagination.sort.map((s) => s.field).join(', ') }`); // eslint-disable-line no-console
     opt = opt || {};
     opt.url = getters.urlFor(type, null, opt);
 
@@ -408,11 +488,7 @@ export default {
       return Promise.reject(e);
     }
 
-    await dispatch('unwatch', {
-      type,
-      all: true,
-    });
-
+    // Of type @StorePagination
     const pagination = opt.pagination ? {
       request: {
         namespace:  opt.namespaced,
@@ -429,11 +505,16 @@ export default {
       commit('loadPage', {
         ctx,
         type,
-        data: out.data,
+        data:     out.data,
         pagination,
+        revision: out.revision,
       });
     }
 
+    if ( !opt.transient && opt.watch !== false ) {
+      dispatch('watch', watchArgs);
+    }
+
     if (opt.hasManualRefresh) {
       dispatch('resource-fetch/updateManualRefreshIsLoading', false, { root: true });
     }
@@ -441,11 +522,73 @@ export default {
     garbageCollect.gcUpdateLastAccessed(ctx, type);
 
     return opt.transient ? {
-      data: out.data,
+      data: await dispatch('createMany', out.data), // Return classified objects
       pagination
     } : findAllGetter(getters, type, opt);
   },
 
+  /**
+   * Find results matching a kube `labelSelector` object
+   *
+   * If result not already cached, make a http request to fetch resources matching the selector/s
+   *
+   * This is different if vai based pagination is on
+   * a) Pagination Enabled - use the new sql-cache backed api - findPage
+   * b) Pagination Disabled - use the old 'native kube api' - findMatching
+   *
+   * Filter is defined via the kube labelSelector object (see KubeLabelSelector)
+   *
+   * opt: @ActionFindLabelSelectorArgs
+   * @returns @ActionFindMatchingResponse (resources[], or if transient { data: resources[], pagination: StorePagination })
+   */
+  async findLabelSelector(ctx, {
+    type,
+    context,
+    matching: {
+      namespace,
+      labelSelector
+    },
+    opt
+  }) {
+    const { getters, dispatch } = ctx;
+    const args = {
+      id: type,
+      context,
+    };
+
+    opt = opt || {};
+
+    if (getters[`paginationEnabled`]?.(args)) {
+      if (isLabelSelectorEmpty(labelSelector)) {
+        throw new Error(`labelSelector must not be empty when using findLabelSelector (avoid fetching all resources)`);
+      }
+
+      // opt of type ActionFindPageArgs
+      return dispatch('findPage', {
+        type,
+        opt: {
+          ...opt,
+          namespaced: namespace,
+          pagination: new FilterArgs({ labelSelector }),
+          transient:  opt?.transient !== undefined ? opt.transient : false // Call this out explicitly here, as by default findX methods ar eusually be cached AND watched
+        }
+      });
+    }
+
+    // opt of type ActionFindPageArgs
+    const findMatching = await dispatch('findMatching', {
+      type,
+      selector: labelSelectorToSelector(labelSelector),
+      opt,
+      namespace,
+    });
+
+    return opt.transient ? { data: findMatching } : findMatching;
+  },
+
+  /**
+   * opt: @ActionFindMatchingArgs
+   */
   async findMatching(ctx, {
     type,
     selector,
@@ -463,7 +606,13 @@ export default {
     if ( !getters.typeRegistered(type) ) {
       commit('registerType', type);
     }
-    if ( opt.force !== true && getters['haveSelector'](type, selector) ) {
+
+    if ( opt.force !== true && getters['haveSelector'](type, selector)) {
+      return getters.all(type);
+    }
+
+    // Optimisation - We can pretend like we've fetched a specific selectors worth instead of replacing ALL pods with only SOME
+    if ( opt.force !== true && getters['haveAll'](type)) {
       return getters.matching( type, selector, namespace );
     }
 
@@ -471,6 +620,8 @@ export default {
 
     opt = opt || {};
     opt.labelSelector = selector;
+    opt.isCollection = true;
+    opt.namespaced = namespace;
     opt.url = getters.urlFor(type, null, opt);
     opt.depaginate = conditionalDepaginate(typeOptions?.depaginate, { ctx, args: { type, opt } });
 
@@ -499,7 +650,7 @@ export default {
 
     garbageCollect.gcUpdateLastAccessed(ctx, type);
 
-    return getters.matching( type, selector, namespace );
+    return getters.all(type);
   },
 
   // opt:
@@ -529,6 +680,12 @@ export default {
       out = getters.byId(type, id);
 
       if ( out ) {
+        if ( opt.watch !== false ) {
+          dispatch('watch', createFindWatchArg({
+            type, id, opt, res: undefined
+          }));
+        }
+
         return out;
       }
     }
@@ -541,26 +698,9 @@ export default {
     await dispatch('load', { data: res });
 
     if ( opt.watch !== false ) {
-      const watchMsg = {
-        type,
-        id,
-        // Although not used by sockets, we need this for when resyncWatch calls find... which needs namespace to construct the url
-        namespace: opt.namespaced,
-        // Override the revision. Used in cases where we need to avoid using the resource's own revision which would be `too old`.
-        // For the above case opt.revision will be `null`. If left as `undefined` the subscribe mechanism will try to determine a revision
-        // from resources in store (which would be this one, with the too old revision)
-        revision:  typeof opt.revision !== 'undefined' ? opt.revision : res?.metadata?.resourceVersion,
-        force:     opt.forceWatch === true,
-      };
-
-      const idx = id.indexOf('/');
-
-      if ( idx > 0 ) {
-        watchMsg.namespace = id.substr(0, idx);
-        watchMsg.id = id.substr(idx + 1);
-      }
-
-      dispatch('watch', watchMsg);
+      dispatch('watch', createFindWatchArg({
+        type, id, opt, res
+      }));
     }
 
     out = getters.byId(type, id);
@@ -570,7 +710,15 @@ export default {
     return out;
   },
 
-  load(ctx, { data, existing }) {
+  /**
+   * Add or update the given resource in the store
+   *
+   * invalidatePageCache
+   * - if something calls `load` then the cache no longer has a page so we invalidate it
+   * - however on resource create or remove this can lead to lists showing nothing... before the new page is fetched
+   * - for those cases avoid invaliding the page cache
+   */
+  load(ctx, { data, existing, invalidatePageCache }) {
     const { getters, commit } = ctx;
 
     let type = normalizeType(data.type);
@@ -603,7 +751,8 @@ export default {
     commit('load', {
       ctx,
       data,
-      existing
+      existing,
+      invalidatePageCache // Avoid havePage invalidation
     });
 
     if ( type === SCHEMA ) {
@@ -671,13 +820,21 @@ export default {
     return classify(ctx, resource.toJSON(), true);
   },
 
-  // Forget a type in the store
-  // Remove all entries for that type and stop watching it
-  forgetType({ commit, dispatch, state }, type) {
+  /**
+   * Remove all cached entries for a resource and stop watches
+   */
+  forgetType({ commit, dispatch, state }, type, compareWatches) {
+    // Stop all known watches
     state.started
-      .filter((entry) => entry.type === type)
+      .filter((entry) => compareWatches ? compareWatches(entry) : entry.type === type)
       .forEach((entry) => dispatch('unwatch', entry));
 
+    // Stop all known back-off watch processes for this type
+    dispatch('resetWatchBackOff', {
+      type, compareWatches, resetStarted: false
+    });
+
+    // Remove entries from store
     commit('forgetType', type);
   },
 

package/plugins/dashboard-store/getters.js

@@ -1,5 +1,5 @@
 
-import { SCHEMA, COUNT } from '@shell/config/types';
+import { SCHEMA, COUNT, POD } from '@shell/config/types';
 
 import { matches } from '@shell/utils/selector';
 import { typeMunge, typeRef, SIMPLE_TYPES } from '@shell/utils/create-yaml';
@@ -9,7 +9,11 @@ import { keyFieldFor, normalizeType } from './normalize';
 import { lookup } from './model-loader';
 import garbageCollect from '@shell/utils/gc/gc';
 import paginationUtils from '@shell/utils/pagination-utils';
+import { labelSelectorToSelector } from '@shell/utils/selector-typed';
 
+/**
+ * opt: ActionFindPageArgs
+ */
 export const urlFor = (state, getters) => (type, id, opt) => {
   opt = opt || {};
   type = getters.normalizeType(type);
@@ -46,6 +50,33 @@ export const urlFor = (state, getters) => (type, id, opt) => {
   return url;
 };
 
+function resourceCount(rootGetters, getters, typeObj) {
+  let _typeObj = typeObj;
+  const { name: type, count } = _typeObj;
+
+  if (!type) {
+    throw new Error(`Resource type required to calc count: ${ JSON.stringify(typeObj) }`);
+  }
+
+  if (!count) {
+    const schema = getters.schemaFor(type);
+    const counts = getters.all(COUNT)?.[0]?.counts || {};
+    const count = counts[type];
+
+    // This object aligns with `Type.vue` `type`
+    _typeObj = {
+      count:       count ? count.summary.count || 0 : null,
+      byNamespace: count ? count.namespaces : {},
+      revision:    count ? count.revision : null,
+      namespaced:  schema?.attributes?.namespaced
+    };
+  }
+
+  const namespaces = _typeObj?.namespaced && !rootGetters.isAllNamespaces ? Object.keys(rootGetters.activeNamespaceCache || {}) : [];
+
+  return matchingCounts(_typeObj, namespaces.length ? namespaces : null);
+}
+
 /**
  * Find the number of resources given
  * - if the type is namespaced
@@ -91,12 +122,59 @@ export default {
     return state.types[type].list;
   },
 
+  /**
+   * This is a _manual_ application of the selector against whatever is in the store
+   *
+   * The store must be populated with enough resources to make this valid
+   *
+   * It's like `matching` except
+   * - it accepts a kube labelSelector object (see KubeLabelSelector)
+   * - if the store already has the selector and only the selector just return it, otherwise run through `matching`
+   */
+  matchingLabelSelector: (state, getters, rootState) => (type, labelSelector, namespace) => {
+    type = getters.normalizeType(type);
+    const selector = labelSelectorToSelector(labelSelector);
+    const page = getters['havePage'](type, selector)?.request;
+
+    // Does the store contain the result of a vai backed api request?
+    if (
+      page?.namespace === namespace &&
+      page?.pagination?.filters?.length === 0 &&
+      page?.pagination.labelSelector &&
+      selector === labelSelectorToSelector(page?.pagination.labelSelector
+      )
+    ) {
+      return getters.all(type);
+    }
+
+    // Does the store contain the result of a specific labelSelector request?
+    if (getters['haveSelector'](type, selector)) {
+      return getters.all(type);
+    }
+
+    if (getters['havePage'](type)) {
+      return getters.all(type);
+    }
+
+    // Does the store have all and we can pretend like it contains a result of a labelSelector?
+    if (getters['haveAll'](type)) {
+      return getters.matching( type, selector, namespace );
+    }
+
+    return [];
+  },
+
+  /**
+   * This is a _manual_ application of the selector against whatever is in the store
+   *
+   * The store must be populated with enough resources to make this valid
+   */
   matching: (state, getters, rootState) => (type, selector, namespace, config = { skipSelector: false }) => {
     let matching = getters['all'](type);
 
     // Filter first by namespace if one is provided, since this is efficient
     if (namespace && typeof namespace === 'string') {
-      matching = matching.filter((obj) => obj.namespace === namespace);
+      matching = type === POD ? getters['podsByNamespace'](namespace) : matching.filter((obj) => obj.namespace === namespace);
     }
 
     garbageCollect.gcUpdateLastAccessed({
@@ -327,6 +405,9 @@ export default {
     return state.types[type]?.haveNamespace || null;
   },
 
+  /**
+   * Returns (type: string ) => StorePagination
+   */
   havePage: (state, getters) => (type) => {
     type = getters.normalizeType(type);
 
@@ -408,30 +489,13 @@ export default {
    *
    */
   count: (state, getters, rootState, rootGetters) => (typeObj) => {
-    let _typeObj = typeObj;
-    const { name: type, count } = _typeObj;
+    const subTypes = rootGetters['type-map/optionsFor'](typeObj.name).subTypes || [];
 
-    if (!type) {
-      throw new Error(`Resource type required to calc count: ${ JSON.stringify(typeObj) }`);
+    if (subTypes.length) {
+      return subTypes.reduce((acc, type) => acc + resourceCount(rootGetters, getters, { name: type }), 0);
     }
 
-    if (!count) {
-      const schema = getters.schemaFor(type);
-      const counts = getters.all(COUNT)?.[0]?.counts || {};
-      const count = counts[type];
-
-      // This object aligns with `Type.vue` `type`
-      _typeObj = {
-        count:       count ? count.summary.count || 0 : null,
-        byNamespace: count ? count.namespaces : {},
-        revision:    count ? count.revision : null,
-        namespaced:  schema?.attributes?.namespaced
-      };
-    }
-
-    const namespaces = _typeObj?.namespaced && !rootGetters.isAllNamespaces ? Object.keys(rootGetters.activeNamespaceCache || {}) : [];
-
-    return matchingCounts(_typeObj, namespaces.length ? namespaces : null);
+    return resourceCount(rootGetters, getters, typeObj);
   },
 
   generation: (state, getters) => (type) => {
@@ -445,7 +509,17 @@ export default {
     return undefined;
   },
 
+  /**
+   * Determine if server-side pagination (SSP) is enabled
+   *
+   * If args is falsy just check the Feature Flag
+   *
+   * Otherwise args should reference a resource who's compatibility with SSP will also be checked
+   */
   paginationEnabled: (state, getters, rootState, rootGetters) => (args) => {
+    if (!args) {
+      return paginationUtils.isSteveCacheEnabled({ rootGetters });
+    }
     const id = typeof args === 'object' ? args.id : args;
     const context = typeof args === 'object' ? args.context : undefined;
 
@@ -453,5 +527,19 @@ export default {
     const resource = id || context ? { id, context } : null;
 
     return paginationUtils.isEnabled({ rootGetters }, { store, resource });
-  }
+  },
+
+  /**
+   * Is the url path a rancher steve one?
+   *
+   * Can be used to change behaviour given steve api
+   */
+  isSteveUrl: (state) => () => false,
+
+  /**
+   * Is the url path a rancher steve one AND the steve cache is enabled?
+   *
+   * Can be used to change behaviour given steve cache api functionality
+   */
+  isSteveCacheUrl: (state) => () => false,
 };