@rancher/shell 0.5.3 → 1.2.1

package/plugins/dashboard-store/actions.js

@@ -72,10 +72,6 @@ export async function loadSchemas(ctx, watch = true) {
   return all;
 }
 
-const findAllGetter = (getters, type, opt) => {
-  return opt.namespaced ? getters.matching(type, null, opt.namespaced, { skipSelector: true }) : getters.all(type);
-};
-
 export default {
   request() {
     throw new Error('Not Implemented');
@@ -157,19 +153,19 @@ export default {
 
     // No need to request the resources if we have them already
     if ( opt.force !== true && (getters['haveAll'](type) || getters['haveAllNamespace'](type, opt.namespaced))) {
-      const args = {
-        type,
-        revision:  '',
-        // watchNamespace - used sometimes when we haven't fetched the results of a single namespace
-        // namespaced - used when we have fetched the result of a single namespace (see https://github.com/rancher/dashboard/pull/7329/files)
-        namespace: opt.watchNamespace || opt.namespaced
-      };
-
       if (opt.watch !== false ) {
+        const args = {
+          type,
+          revision:  '',
+          // watchNamespace - used sometimes when we haven't fetched the results of a single namespace
+          // namespaced - used when we have fetched the result of a single namespace (see https://github.com/rancher/dashboard/pull/7329/files)
+          namespace: opt.watchNamespace || opt.namespaced
+        };
+
         dispatch('watch', args);
       }
 
-      return findAllGetter(getters, type, opt);
+      return getters.all(type);
     }
 
     let load = (opt.load === undefined ? _ALL : opt.load);
@@ -334,7 +330,7 @@ export default {
       dispatch('watch', args);
     }
 
-    const all = findAllGetter(getters, type, opt);
+    const all = getters.all(type);
 
     if (!opt.incremental && opt.hasManualRefresh) {
       dispatch('resource-fetch/updateManualRefreshIsLoading', false, { root: true });
@@ -443,8 +439,13 @@ export default {
       const watchMsg = {
         type,
         id,
-        revision: res?.metadata?.resourceVersion,
-        force:    opt.forceWatch === true,
+        // 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('/');

package/plugins/dashboard-store/classify.js

@@ -12,7 +12,24 @@ export function classify(ctx, obj, isClone = false) {
 
   const customModel = ctx.getters['classify'](obj);
 
-  const out = new customModel(obj, ctx, null, isClone);
+  const out = new customModel(obj, ctx, (process.server ? ctx.state.config.namespace : null), isClone);
+
+  if ( process.server ) {
+    Object.defineProperty(obj, '__rehydrate', {
+      value:        ctx.state.config.namespace,
+      enumerable:   true,
+      configurable: true
+    });
+
+    if ( isClone ) {
+      Object.defineProperty(obj, '__clone', {
+        value:        true,
+        enumerable:   true,
+        configurable: true,
+        writable:     true
+      });
+    }
+  }
 
   return out;
 }

package/plugins/dashboard-store/getters.js

@@ -1,5 +1,5 @@
 
-import { SCHEMA, COUNT } from '@shell/config/types';
+import { SCHEMA } from '@shell/config/types';
 
 import { matches } from '@shell/utils/selector';
 import { typeMunge, typeRef, SIMPLE_TYPES } from '@shell/utils/create-yaml';
@@ -45,29 +45,6 @@ export const urlFor = (state, getters) => (type, id, opt) => {
   return url;
 };
 
-/**
- * Find the number of resources given
- * - if the type is namespaced
- * - if there are any counts per namespace
- * - if there are no namespaces
- * - if there is no total count
- */
-function matchingCounts(typeObj, namespaces) {
-  // That was easy
-  if ( !typeObj.namespaced || !typeObj.byNamespace || namespaces === null || typeObj.count === null) {
-    return typeObj.count;
-  }
-
-  let out = 0;
-
-  // Otherwise start with 0 and count up
-  for ( const namespace of namespaces ) {
-    out += typeObj.byNamespace[namespace]?.count || 0;
-  }
-
-  return out;
-}
-
 export default {
 
   all: (state, getters, rootState) => (type) => {
@@ -87,24 +64,19 @@ export default {
     return state.types[type].list;
   },
 
-  matching: (state, getters, rootState) => (type, selector, namespace, config = { skipSelector: false }) => {
-    let matching = getters['all'](type);
+  matching: (state, getters, rootState) => (type, selector, namespace) => {
+    let all = 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);
+    if (namespace) {
+      all = all.filter((obj) => obj.namespace === namespace);
     }
 
     garbageCollect.gcUpdateLastAccessed({
       state, getters, rootState
     }, type);
 
-    // Looks like a falsy selector is a thing, so if we're not interested in filtering by the selector... explicitly avoid it
-    if (config.skipSelector) {
-      return matching;
-    }
-
-    return matching.filter((obj) => {
+    return all.filter((obj) => {
       return matches(obj, selector);
     });
   },
@@ -368,40 +340,5 @@ export default {
 
   gcIgnoreTypes: () => {
     return {};
-  },
-
-  /**
-   * For the given type, and it's settings, find the number of resources associated with it
-   *
-   * This takes into account if the type is namespaced.
-   *
-   * @param typeObj see inners for properties. must have at least `name` (resource type)
-   *
-   */
-  count: (state, getters, rootState, rootGetters) => (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];
-
-      _typeObj = {
-        count:       count ? count.summary.count || 0 : null,
-        byNamespace: count ? count.namespaces : {},
-        revision:    count ? count.revision : null,
-        namespaced:  schema?.attributes?.namespaced
-      };
-    }
-
-    const namespaces = Object.keys(rootGetters.activeNamespaceCache || {});
-
-    return matchingCounts(_typeObj, namespaces.length ? namespaces : null);
-  },
-
+  }
 };

package/plugins/dashboard-store/index.js

@@ -33,9 +33,21 @@ export default (vuexModule, config, init) => {
   const namespace = config.namespace || '';
 
   return function(store) {
+    // const inst = SteveFactory(namespace, config.baseUrl);
+
     store.registerModule(namespace, vuexModule);
     store.commit(`${ namespace }/applyConfig`, config);
 
+    if ( !process.client ) {
+      return;
+    }
+
+    // store.subscribe(({ type }, state) => {
+    //   if ( type === 'auth/loggedOut' ) {
+    //     store.dispatch(`${ namespace }/unsubscribe`);
+    //   }
+    // });
+
     const module = store._modules.root._children[namespace];
     const fromServer = window.__NUXT__;
 

package/plugins/dashboard-store/mutations.js

@@ -23,6 +23,10 @@ function registerType(state, type) {
     // Not enumerable so they don't get sent back to the client for SSR
     Object.defineProperty(cache, 'map', { value: new Map() });
 
+    if ( process.server && !cache.list.__rehydrateAll ) {
+      Object.defineProperty(cache.list, '__rehydrateAll', { value: `${ state.config.namespace }/${ type }`, enumerable: true });
+    }
+
     Vue.set(state.types, type, cache);
   }
 

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

@@ -105,7 +105,6 @@ export const STATES_ENUM = {
   ERRORING:         'erroring',
   ERRORS:           'errors',
   EXPIRED:          'expired',
-  EXPIRING:         'expiring',
   FAIL:             'fail',
   FAILED:           'failed',
   HEALTHY:          'healthy',
@@ -168,13 +167,6 @@ export const STATES_ENUM = {
   WARNING:          'warning',
 };
 
-export function mapStateToEnum(statusString) {
-  // e.g. in fleet Status is Capitalized. This function will map it to the enum
-  return Object.values(STATES_ENUM).find((val) => {
-    return val.toLowerCase() === statusString.toLocaleLowerCase();
-  });
-}
-
 export const STATES = {
   [STATES_ENUM.IN_USE]: {
     color: 'success', icon: 'dot-open', label: 'In Use', compoundIcon: 'checkmark'
@@ -261,10 +253,7 @@ export const STATES = {
     color: 'error', icon: 'error', label: 'Errors', compoundIcon: 'error'
   },
   [STATES_ENUM.EXPIRED]: {
-    color: 'error', icon: 'error', label: 'Expired', compoundIcon: 'warning'
-  },
-  [STATES_ENUM.EXPIRING]: {
-    color: 'warning', icon: 'error', label: 'Expiring', compoundIcon: 'error'
+    color: 'warning', icon: 'error', label: 'Expired', compoundIcon: 'warning'
   },
   [STATES_ENUM.FAIL]: {
     color: 'error', icon: 'error', label: 'Fail', compoundIcon: 'error'
@@ -523,28 +512,6 @@ export function stateDisplay(state) {
   return key.split(/-/).map(ucFirst).join('-');
 }
 
-export function primaryDisplayStatusFromCount(status) {
-  const statusOrder = [
-    STATES_ENUM.ERROR,
-    STATES_ENUM.FAILED,
-    STATES_ENUM.WARNING,
-    STATES_ENUM.MODIFIED,
-    STATES_ENUM.WAIT_APPLIED,
-    STATES_ENUM.ORPHANED,
-    STATES_ENUM.MISSING,
-    STATES_ENUM.UNKNOWN,
-    STATES_ENUM.NOT_READY,
-    STATES_ENUM.READY,
-  ];
-
-  // sort status by order of statusOrder
-  const existingStatuses = Object.keys(status).filter((key) => {
-    return status[key] > 0 && statusOrder.includes(key.toLowerCase());
-  }).sort((a, b) => statusOrder.indexOf(a.toLowerCase()) - statusOrder.indexOf(b.toLowerCase()));
-
-  return existingStatuses[0] ? existingStatuses[0] : STATES_ENUM.UNKNOWN;
-}
-
 export function stateSort(color, display) {
   color = color.replace(/^(text|bg)-/, '');
 
@@ -1122,16 +1089,6 @@ export default class Resource {
     return this._save(...arguments);
   }
 
-  /**
-   * Remove any unwanted properties from the object that will be saved
-   */
-  cleanForSave(data, forNew) {
-    delete data.__rehydrate;
-    delete data.__clone;
-
-    return data;
-  }
-
   /**
    * Allow to handle the response of the save request
    * @param {*} res Full request response
@@ -1139,6 +1096,9 @@ export default class Resource {
   processSaveResponse(res) { }
 
   async _save(opt = {}) {
+    delete this.__rehydrate;
+    delete this.__clone;
+
     const forNew = !this.id;
 
     const errors = await this.validationErrors(this, opt.ignoreFields);
@@ -1185,24 +1145,22 @@ export default class Resource {
     // @TODO remove this once the API maps steve _type <-> k8s type in both directions
     opt.data = this.toSave() || { ...this };
 
-    if (opt.data._type) {
+    if (opt?.data._type) {
       opt.data.type = opt.data._type;
     }
 
-    if (opt.data._name) {
+    if (opt?.data._name) {
       opt.data.name = opt.data._name;
     }
 
-    if (opt.data._labels) {
+    if (opt?.data._labels) {
       opt.data.labels = opt.data._labels;
     }
 
-    if (opt.data._annotations) {
+    if (opt?.data._annotations) {
       opt.data.annotations = opt.data._annotations;
     }
 
-    opt.data = this.cleanForSave(opt.data, forNew);
-
     // handle "replace" opt as a query param _replace=true for norman PUT requests
     if (opt?.replace && opt.method === 'put') {
       const argParam = opt.url.includes('?') ? '&' : '?';
@@ -1260,11 +1218,19 @@ export default class Resource {
   // ------------------------------------------------------------------
 
   currentRoute() {
-    return window.$nuxt.$route;
+    if ( process.server ) {
+      return this.$rootState.$route;
+    } else {
+      return window.$nuxt.$route;
+    }
   }
 
   currentRouter() {
-    return window.$nuxt.$router;
+    if ( process.server ) {
+      return this.$rootState.$router;
+    } else {
+      return window.$nuxt.$router;
+    }
   }
 
   get listLocation() {
@@ -1381,7 +1347,7 @@ export default class Resource {
 
   async download() {
     const value = await this.followLink('view', { headers: { accept: 'application/yaml' } });
-    const data = await this.cleanForDownload(value.data);
+    const data = await this.$dispatch('cleanForDownload', value.data);
 
     downloadFile(`${ this.nameDisplay }.yaml`, data, 'application/yaml');
   }
@@ -1404,7 +1370,7 @@ export default class Resource {
     await eachLimit(items, 10, (item, idx) => {
       return item.followLink('view', { headers: { accept: 'application/yaml' } } ).then(async(data) => {
         const yaml = data.data || data;
-        const cleanedYaml = await this.cleanForDownload(yaml);
+        const cleanedYaml = await this.$dispatch('cleanForDownload', yaml);
 
         files[`resources/${ names[idx] }`] = cleanedYaml;
       });
@@ -1481,10 +1447,6 @@ export default class Resource {
     this.$dispatch(`cleanForDiff`, this.toJSON());
   }
 
-  async cleanForDownload(yaml) {
-    return this.$dispatch(`cleanForDownload`, yaml);
-  }
-
   yamlForSave(yaml) {
     try {
       const obj = jsyaml.load(yaml);
@@ -1969,11 +1931,4 @@ export default class Resource {
   get creationTimestamp() {
     return this.metadata?.creationTimestamp;
   }
-
-  /**
-   * Allows model to specify JSON Paths that should be folded in the YAML editor by default
-   */
-  get yamlFolding() {
-    return [];
-  }
 }

package/plugins/i18n.js

@@ -1,7 +1,7 @@
 import Vue from 'vue';
 import { escapeHtml } from '../utils/string';
 
-function stringFor(store, key, args, raw = false, escapehtml = true) {
+export function stringFor(store, key, args, raw = false, escapehtml = true) {
   const translation = store.getters['i18n/t'](key, args);
 
   let out;

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

@@ -5,36 +5,63 @@ const { urlFor, urlOptions } = _getters;
 describe('steve: getters', () => {
   describe('steve > getters > urlFor', () => {
     // we're not testing function output based off of state or getter inputs here since they are dependencies
-    const state = { config: { baseUrl: 'protocol' } };
+    const baseUrl = '/v1';
+    const collectionUrl = 'https://abc.com/v1/urlFoo';
+    const namespace = 'myNamespace';
+    const state = { config: { baseUrl } };
     const getters = {
-      normalizeType: (type) => type,
-      schemaFor:     (type) => {
-        if (type === 'typeFoo') {
-          return { links: { collection: 'urlFoo' } };
+      normalizeType: (type: string) => type,
+      schemaFor:     (type: string) => {
+        if (type === 'rType') {
+          return { links: { collection: collectionUrl } };
+        }
+        if (type === 'trailingforwardslash') {
+          return { links: { collection: `${ collectionUrl }/` } };
         }
       },
       // this has its own tests so it just returns the input string
-      urlOptions: (string) => string
+      urlOptions: (url: string, opt: any) => {
+        if (opt.addParam) {
+          url += '?param=true';
+        }
+
+        return url;
+      }
     };
 
     const urlForGetter = urlFor(state, getters);
 
     // most tests for this getter will go through the dashboard-store getters test spec, this only tests logic specific to the steve variant
 
-    it('expects urlFor to return a function', () => {
-      expect(typeof urlFor(state, getters)).toBe('function');
-    });
+    it.each([
+      ['rType', undefined, undefined, collectionUrl],
 
-    it('expects function returned by urlFor to return a string a type', () => {
-      expect(urlForGetter('typeFoo')).toBe('protocol/urlFoo');
-    });
+      // No namespace
+      ['rType', undefined, { }, `${ collectionUrl }`],
+      ['rType', undefined, { addParam: true }, `${ collectionUrl }?param=true`],
+      ['rType', 'abc', { }, `${ collectionUrl }/abc`],
+      ['rType', 'abc', { addParam: true }, `${ collectionUrl }/abc?param=true`],
 
-    it('expects function returned by urlFor to return a string containing a namespace when provided with a type and a single namespace string', () => {
-      expect(urlForGetter('typeFoo', undefined, { namespaced: 'nsBar' })).toBe('protocol/urlFoo/nsBar');
-    });
+      // With namespace
+      ['rType', undefined, { namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }`],
+      ['rType', undefined, { addParam: true, namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }?param=true`],
+      ['rType', 'abc', { namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }/abc`],
+      ['rType', 'abc', { addParam: true, namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }/abc?param=true`],
+
+      // With url (mostly no op)
+      ['rType', undefined, { url: `${ baseUrl }/urlFoo`, namespaced: `${ namespace }` }, `${ baseUrl }/urlFoo`],
+      ['rType', undefined, { url: `${ baseUrl }/urlFoo/abc`, namespaced: `${ namespace }` }, `${ baseUrl }/urlFoo/abc`],
+      ['rType', undefined, { url: `/urlFoo`, namespaced: `${ namespace }` }, `/urlFoo`],
+      ['rType', undefined, { url: `/urlFoo/abc`, namespaced: `${ namespace }` }, `/urlFoo/abc`],
+
+      // multiple namespaces (no op)
+      ['rType', undefined, { namespaced: [`${ namespace }`, 'nsBaz'] }, `${ collectionUrl }`],
 
-    it('expects function returned by urlFor to return a string not containing a namespace when provided with a type and a multiple namespaces string', () => {
-      expect(urlForGetter('typeFoo', undefined, { namespaced: ['nsBar', 'nsBaz'] })).toBe('protocol/urlFoo');
+      // handle trailing space
+      ['trailingforwardslash', undefined, { namespaced: `${ namespace }` }, `${ collectionUrl }/${ namespace }`],
+
+    ])("given type '%p', id '%p' and opt '%p', should get url '%p'", (type, id, opt, url) => {
+      expect(urlForGetter(type, id, opt)).toBe(url);
     });
   });
 
@@ -43,13 +70,8 @@ describe('steve: getters', () => {
     const state = { config: { baseUrl: 'protocol' } };
     const getters = {
       normalizeType: (type) => type,
-      schemaFor:     (type) => {
-        if (type === 'typeFoo') {
-          return { links: { collection: 'urlFoo' } };
-        }
-      },
       // this has its own tests so it just returns the input string
-      urlOptions: (string) => string
+      urlOptions:    (string) => string
     };
 
     const urlOptionsGetter = urlOptions();
@@ -72,8 +94,8 @@ describe('steve: getters', () => {
     it('returns a string with a single filter statement applied and formatted for steve if a single filter statement is applied and the url starts with "/v1"', () => {
       expect(urlOptionsGetter('/v1/foo', { filter: { bar: 'baz' } })).toBe('/v1/foo?filter=bar=baz&exclude=metadata.managedFields');
     });
-    it('returns a string with a single filter statement applied and formatted for steve if a single filter statement is applied and the url starts with "/k8s/clusters/c-m-n4x45x4b/v1/"', () => {
-      expect(urlOptionsGetter('/k8s/clusters/c-m-n4x45x4b/v1/foo', { filter: { bar: 'baz' } })).toBe('/k8s/clusters/c-m-n4x45x4b/v1/foo?filter=bar=baz&exclude=metadata.managedFields');
+    it('returns a string with a single filter statement applied and formatted for steve if a single filter statement is NOT applied and the url starts with "/k8s/clusters/c-m-n4x45x4b/v1/"', () => {
+      expect(urlOptionsGetter('/k8s/clusters/c-m-n4x45x4b/v1/foo', { filter: { bar: 'baz' } })).toBe('/k8s/clusters/c-m-n4x45x4b/v1/foo?bar=baz');
     });
     it('returns a string with a multiple filter statements applied if a single filter statement is applied', () => {
       expect(urlOptionsGetter('foo', { filter: { bar: 'baz', far: 'faz' } })).toBe('foo?bar=baz&far=faz');
@@ -93,7 +115,7 @@ describe('steve: getters', () => {
     it('returns a string without an exclude statement if excludeFields is but the url does not start with "/v1/"', () => {
       expect(urlOptionsGetter('foo', { excludeFields: ['bar'] })).toBe('foo');
     });
-    it('returns a string without an exclude statement if excludeFields is an array but the URL doesnt include the "/v1/ string"', () => {
+    it('returns a string without an exclude statement if excludeFields is an array but the URL doesn\'t include the "/v1/ string"', () => {
       expect(urlOptionsGetter('foo', { excludeFields: ['bar'] })).toBe('foo');
     });
     it('returns a string with a limit applied if a limit is provided', () => {

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

@@ -0,0 +1,106 @@
+import { actions } from '../subscribe';
+
+describe('steve: subscribe', () => {
+  describe('actions', () => {
+    describe('watch', () => {
+      const state = {};
+      const getters = {
+        normalizeType: (type: string) => type,
+        schemaFor:     () => null,
+        inError:       () => false,
+        watchStarted:  () => false,
+      };
+      const rootGetters = { 'type-map/isSpoofed': () => false };
+
+      const type = 'test';
+      const selector = undefined;
+      const id = undefined;
+      const revision = 1;
+      const namespace = undefined;
+      const stop = false;
+      const force = undefined;
+
+      it('no schema', () => {
+        const dispatch = jest.fn();
+
+        actions.watch({
+          state, dispatch, getters, rootGetters
+        }, {
+          type, selector, id, revision, namespace, stop, force
+        });
+
+        expect(dispatch).toHaveBeenCalledWith('send', {
+          resourceType:    type,
+          resourceVersion: revision.toString(),
+
+        });
+      });
+
+      it('schema with watch verb', () => {
+        const dispatch = jest.fn();
+        const testGetters = {
+          ...getters,
+          schemaFor: (type: string) => ({ attributes: { verbs: ['watch'] } }),
+        };
+
+        actions.watch({
+          state, dispatch, getters: testGetters, rootGetters
+        }, {
+          type, selector, id, revision, namespace, stop, force
+        });
+
+        expect(dispatch).toHaveBeenCalledWith('send', {
+          resourceType:    type,
+          resourceVersion: revision.toString(),
+        });
+      });
+
+      it('schema with no watch verb', () => {
+        const dispatch = jest.fn();
+        const testGetters = {
+          ...getters,
+          schemaFor: (type: string) => ({ attributes: { verbs: [] } }),
+        };
+
+        actions.watch({
+          state, dispatch, getters: testGetters, rootGetters
+        }, {
+          type, selector, id, revision, namespace, stop, force
+        });
+
+        expect(dispatch).not.toHaveBeenCalled();
+      });
+
+      it('don\'t watch when the watch is in error', () => {
+        const dispatch = jest.fn();
+        const testGetters = {
+          ...getters,
+          inError: (params: any) => true,
+        };
+
+        actions.watch({
+          state, dispatch, getters: testGetters, rootGetters
+        }, {
+          type, selector, id, revision, namespace, stop, force
+        });
+
+        expect(dispatch).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('ws.resource.error', () => {
+      it('handle no permission error', () => {
+        const commit = jest.fn();
+        const getters = { storeName: 'storeName' };
+        const dispatch = undefined;
+
+        const msg = { data: { error: 'the server does not allow this method on the requested resource' } };
+
+        actions['ws.resource.error']({
+          getters, commit, dispatch
+        }, msg);
+        expect(commit).toHaveBeenCalledWith('setInError', { msg, reason: 'NO_PERMS' });
+      });
+    });
+  });
+});