@rancher/shell 3.0.5-rc.3 → 3.0.5-rc.5

package/pages/explorer/resource/detail/configmap.vue

@@ -0,0 +1,19 @@
+<script setup lang="ts">
+import DetailPage from '@shell/components/Resource/Detail/Page.vue';
+import { CONFIG_MAP } from '@shell/config/types';
+import { useStore } from 'vuex';
+
+const store = useStore();
+const configMaps = await store.dispatch('cluster/findAll', { type: CONFIG_MAP });
+
+</script>
+<template>
+  <DetailPage>
+    <template #top-area>
+      ConfigMap
+    </template>
+    <template #middle-area>
+      {{ configMaps }}
+    </template>
+  </DetailPage>
+</template>

package/plugins/dashboard-store/actions.js

@@ -9,6 +9,7 @@ import garbageCollect from '@shell/utils/gc/gc';
 import { addSchemaIndexFields } from '@shell/plugins/steve/schema.utils';
 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';
 
@@ -183,7 +184,6 @@ export default {
 
     opt = opt || {};
     type = getters.normalizeType(type);
-
     if ( !getters.typeRegistered(type) ) {
       commit('registerType', type);
     }
@@ -426,8 +426,20 @@ 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);
     }
 
@@ -451,11 +463,7 @@ export default {
       return Promise.reject(e);
     }
 
-    await dispatch('unwatch', {
-      type,
-      all: true,
-    });
-
+    // Of type @StorePagination
     const pagination = opt.pagination ? {
       request: {
         namespace:  opt.namespaced,
@@ -472,11 +480,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 });
     }
@@ -671,7 +684,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);
@@ -704,7 +725,8 @@ export default {
     commit('load', {
       ctx,
       data,
-      existing
+      existing,
+      invalidatePageCache // Avoid havePage invalidation
     });
 
     if ( type === SCHEMA ) {

package/plugins/dashboard-store/getters.js

@@ -50,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
@@ -374,6 +401,9 @@ export default {
     return state.types[type]?.haveNamespace || null;
   },
 
+  /**
+   * Returns (type: string ) => StorePagination
+   */
   havePage: (state, getters) => (type) => {
     type = getters.normalizeType(type);
 
@@ -455,30 +485,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) => {

package/plugins/dashboard-store/mutations.js

@@ -86,8 +86,16 @@ export function createLoadArgs(ctx, dataType) {
   };
 }
 
+/**
+ * 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
+ */
 export function load(state, {
-  data, ctx, existing, cachedArgs
+  data, ctx, existing, cachedArgs, invalidatePageCache = true,
 }) {
   const { getters } = ctx;
   // Optimisation. This can run once per resource loaded.., so pass in from parent
@@ -130,8 +138,12 @@ export function load(state, {
     }
   } else {
     if (inMap) {
+      // In theory cached `entry` should match provided `existing`, so changes merged from `data` into `entry` should be reflected in `existing`.
+      // However.. there's a disconnect happening somewhere so merge data into `existing` before merging into `entry`
+      const latestEntry = existing && entry !== existing ? replaceResource(existing, data, getters) : data;
+
       // There's already an entry in the store, so merge changes into it. The list entry is a reference to the map (and vice versa)
-      entry = replaceResource(entry, data, getters);
+      entry = replaceResource(entry, latestEntry, getters);
     } else {
       // There's no entry, make a new proxy
       entry = reactive(classify(ctx, data));
@@ -164,7 +176,8 @@ export function load(state, {
     }
   }
 
-  cache.havePage = false;
+  // see `invalidatePageCache` description above
+  cache.havePage = invalidatePageCache ? false : cache.havePage;
 
   return entry;
 }
@@ -476,29 +489,60 @@ export default {
     data,
     ctx,
     pagination,
+    revision
   }) {
     if (!data) {
       return;
     }
+    // We loop over data three times in this mutator, which is bad
+    // However we're only dealing with pageSize worth of data and splitting out into three loops improves legibility
 
     const keyField = ctx.getters.keyFieldForType(type);
-    const proxies = reactive(data.map((x) => classify(ctx, x)));
+
+    // Why don't we just replace the map? Because we
+    // 1. nav to list, subscribe to changes
+    // 2. nav to resource in list
+    // 3. update to page comes over
+    // 4. need to update the reference the detail list uses
+    const proxiesMap = {};
+    const proxies = reactive(data.map((x) => {
+      proxiesMap[x[keyField]] = true;
+
+      return classify(ctx, x);
+    }));
     const cache = registerType(state, type);
 
-    clear(cache.list);
-    cache.map.clear();
     cache.generation++;
 
+    // Update list
+    clear(cache.list);
     addObjects(cache.list, proxies);
 
+    // Update Map (remove stale)
+    cache.map.forEach((value, key) => {
+      if (!proxiesMap[value[keyField]]) {
+        cache.map.delete(key);
+      }
+    });
+
+    // Update Map (update existing / add latest)
     for ( let i = 0 ; i < proxies.length ; i++ ) {
-      cache.map.set(proxies[i][keyField], proxies[i]);
+      // This could probably be merged with the first loop above
+      const existing = cache.map.get(proxies[i][keyField]);
+      const latest = proxies[i];
+
+      if (existing) {
+        replaceResource(existing, latest, ctx.getters);
+      } else {
+        cache.map.set(latest[keyField], latest);
+      }
     }
 
     // havePage is of type `StorePagination`
     cache.havePage = pagination;
     cache.haveNamespace = undefined;
     cache.haveAll = undefined;
+    cache.revision = revision;
 
     return proxies;
   },

package/plugins/dashboard-store/resource-class.js

@@ -1180,7 +1180,8 @@ export default class Resource {
     }
 
     // @TODO remove this once the API maps steve _type <-> k8s type in both directions
-    // Completely disconnect the object we're going to save (and mangle in cleanForSave) and `this`
+    // `JSON.parse(JSON.stringify` - Completely disconnect the object we're going to send and `this`. This ensures that properties
+    // removed from opt.data before sending (as part of cleanForSave) are not stripped from where they're still needed (`this`)
     opt.data = this.toSave() || JSON.parse(JSON.stringify(this));
 
     if (opt.data._type) {
@@ -1248,7 +1249,18 @@ export default class Resource {
 
     const res = await this.$dispatch('request', { opt, type: this.type } );
 
-    if ( res?._status === 204 ) {
+    // In theory...
+    // 200 - resource could have finalizer (could hang around, keep resource to show deleting state)
+    // 204 - resource should be gone gone (so remove immediately)
+    // However...
+    // 200 - this is the only status code returned
+    if ( res?._status === 200 ) {
+      // Show state (probably terminating) immediately, don't wait for resource.change or debounced resource.changes update
+      // It would be neater to only do this in the debounced resource.changes world, but there's no neat / complete way to do this (paginationUtils will cause dep issues if imported)
+      await this.$dispatch('load', {
+        data: res, existing: this, invalidatePageCache: false
+      });
+    } else if ( res?._status === 204 ) {
       // If there's no body, assume the resource was immediately deleted
       // and drop it from the store as if a remove event happened.
       await this.$dispatch('ws.resource.remove', { data: this });

package/plugins/steve/__tests__/subscribe.spec.ts

@@ -1,4 +1,4 @@
-import { actions } from '../subscribe';
+import { actions, getters } from '../subscribe';
 
 describe('steve: subscribe', () => {
   describe('actions', () => {
@@ -106,4 +106,69 @@ describe('steve: subscribe', () => {
       });
     });
   });
+
+  describe('getters', () => {
+    describe('nextResourceVersion', () => {
+      const myType = 'myType';
+      const myId = `myId`;
+
+      type Revision = string | number | null | undefined
+
+      const createState = (revision?: Revision, cachedList?: any[] ) => {
+        const typeState: any = {};
+
+        if (revision !== undefined) {
+          typeState.revision = revision;
+        }
+        if (cachedList !== undefined) {
+          typeState.list = cachedList;
+        } else {
+          typeState.list = [];
+        }
+
+        return { types: { [myType.toLocaleLowerCase()]: typeState } };
+      };
+
+      const createGetters = (revision?: Revision) => {
+        return {
+          byId: (type: any, id: any) => {
+            expect(type).toBe(myType.toLowerCase());
+            expect(id).toBe(myId);
+
+            return { metadata: { resourceVersion: revision } };
+          }
+        };
+      };
+
+      it.each([
+        ['Is String, Return String', createGetters('abc'), myId, 'abc'],
+        // This catches old parseInt errors
+        ['Is String, Return String (integer prefix)', createGetters('123-abc'), myId, '123-abc'],
+        // This catches old parseInt errors
+        ['Is String, Return String (integer postfix)', createGetters('abc-123'), myId, 'abc-123'],
+        ['Is 0, Return Null', createGetters(0), myId, null],
+        ['Is Number, Return Number', createGetters(123), myId, 123],
+        ['Is Missing (null), Return Null', createGetters(null), myId, null],
+        ['Is Missing (undefined), Return Null', createGetters(undefined), myId, null],
+      ])('test revision from a single resource - %s', (_, storeGetters, id, expected) => {
+        expect(getters.nextResourceVersion(createState(), storeGetters)(myType, id)).toBe(expected);
+      });
+
+      const createResource = (revision: Revision) => ({ metadata: { resourceVersion: revision } });
+
+      it.each([
+        ['Is String, Return String', createState('abc'), 'abc'],
+        ['Is String, Return String (integer prefix)', createState('123-abc'), '123-abc'],
+        ['Is String, Return String (integer postfix)', createState('abc-123'), 'abc-123'],
+        ['Is 0, Return Null (nothing in cache)', createState(0), null],
+        ['Is 0, Return Number (numbers in cache)', createState(0, [createResource(1), createResource(2), createResource(3)]), 3],
+        ['Is 0, Return Number (numbers and strings in cache)', createState(0, [createResource(1), createResource('abc-2'), createResource('3-abc')]), 1],
+        ['Is 0, Return Null (only strings in cache)', createState(0, [createResource('abc'), createResource('abc-2'), createResource('3-abc')]), null],
+        ['Is missing (undefined), Return Null ', createState(undefined), null],
+        ['Is missing (null), Return Null', createState(null), null],
+      ])('test revision from a collection - %s', (_, state, expected) => {
+        expect(getters.nextResourceVersion(state, {})(myType)).toBe(expected);
+      });
+    });
+  });
 });

package/plugins/steve/actions.js

@@ -58,6 +58,9 @@ export default {
       waiting = state.deferredRequests[key];
 
       if ( waiting ) {
+        // A matching request has already been made and is currently waiting to complete
+        // Avoid making another request, just wait for the original one to complete
+        // and return the result of the first call (see `waiting` being processed far below)
         const later = deferred();
 
         waiting.push(later);

package/plugins/steve/steve-pagination-utils.ts

@@ -649,7 +649,7 @@ export const PAGINATION_SETTINGS_STORE_DEFAULTS: PaginationSettingsStore = {
         enabled: [
           NODE, EVENT,
           WORKLOAD_TYPES.CRON_JOB, WORKLOAD_TYPES.DAEMON_SET, WORKLOAD_TYPES.DEPLOYMENT, WORKLOAD_TYPES.JOB, WORKLOAD_TYPES.STATEFUL_SET, POD,
-          CATALOG.APP, CATALOG.CLUSTER_REPO, CATALOG.OPERATION,
+          CATALOG.APP, CATALOG.OPERATION,
           HPA, INGRESS, SERVICE,
           PV, CONFIG_MAP, STORAGE_CLASS, PVC, SECRET,
           WORKLOAD_TYPES.REPLICA_SET, WORKLOAD_TYPES.REPLICATION_CONTROLLER
@@ -658,18 +658,19 @@ export const PAGINATION_SETTINGS_STORE_DEFAULTS: PaginationSettingsStore = {
       }
     }
   },
-  management: {
-    resources: {
-      enableAll:  false,
-      enableSome: {
-        enabled: [
-          { resource: CAPI.RANCHER_CLUSTER, context: ['home', 'side-bar'] },
-          { resource: MANAGEMENT.CLUSTER, context: ['side-bar'] },
-        ],
-        generic: false,
-      }
-    }
-  }
+  // Disabled due to https://github.com/rancher/dashboard/issues/14493
+  // management: {
+  //   resources: {
+  //     enableAll:  false,
+  //     enableSome: {
+  //       enabled: [
+  //         { resource: CAPI.RANCHER_CLUSTER, context: ['home', 'side-bar'] },
+  //         { resource: MANAGEMENT.CLUSTER, context: ['side-bar'] },
+  //       ],
+  //       generic: false,
+  //     }
+  //   }
+  // }
 };
 
 export default new StevePaginationUtils();