@rancher/shell 0.5.2 → 0.5.3

package/plugins/dashboard-store/actions.js

@@ -7,6 +7,7 @@ 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';
 
 export const _ALL = 'all';
 export const _MERGE = 'merge';
@@ -208,12 +209,12 @@ export default {
 
       const pageFetchOpts = {
         ...opt,
-        url: `${ opt.url }?limit=${ opt.incremental }`
+        url: addParam(opt.url, 'limit', `${ opt.incremental }`),
       };
 
       // this is where we "hijack" the limit for the dispatch('request') some lines below
       // and therefore have 2 initial requests in parallel
-      opt.url = `${ opt.url }?limit=100`;
+      opt.url = addParam(opt.url, 'limit', '100');
       skipHaveAll = true;
 
       // since we are forcing a request, clear the haveAll
@@ -368,10 +369,7 @@ export default {
     const typeOptions = rootGetters['type-map/optionsFor'](type);
 
     opt = opt || {};
-
-    opt.filter = opt.filter || {};
-    opt.filter['labelSelector'] = selector;
-
+    opt.labelSelector = selector;
     opt.url = getters.urlFor(type, null, opt);
     opt.depaginate = typeOptions?.depaginate;
 

package/plugins/dashboard-store/getters.js

@@ -1,5 +1,5 @@
 
-import { SCHEMA } from '@shell/config/types';
+import { SCHEMA, COUNT } from '@shell/config/types';
 
 import { matches } from '@shell/utils/selector';
 import { typeMunge, typeRef, SIMPLE_TYPES } from '@shell/utils/create-yaml';
@@ -45,6 +45,29 @@ 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) => {
@@ -345,5 +368,40 @@ 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/resource-class.js

@@ -1381,7 +1381,7 @@ export default class Resource {
 
   async download() {
     const value = await this.followLink('view', { headers: { accept: 'application/yaml' } });
-    const data = await this.$dispatch('cleanForDownload', value.data);
+    const data = await this.cleanForDownload(value.data);
 
     downloadFile(`${ this.nameDisplay }.yaml`, data, 'application/yaml');
   }
@@ -1404,7 +1404,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.$dispatch('cleanForDownload', yaml);
+        const cleanedYaml = await this.cleanForDownload(yaml);
 
         files[`resources/${ names[idx] }`] = cleanedYaml;
       });
@@ -1481,6 +1481,10 @@ 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);

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

@@ -37,6 +37,7 @@ describe('steve: getters', () => {
       expect(urlForGetter('typeFoo', undefined, { namespaced: ['nsBar', 'nsBaz'] })).toBe('protocol/urlFoo');
     });
   });
+
   describe('steve > getters > urlOptions', () => {
     // we're not testing function output based off of state or getter inputs here since they are dependencies
     const state = { config: { baseUrl: 'protocol' } };
@@ -71,12 +72,21 @@ 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 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');
     });
     it('returns a string with a multiple filter statements 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', far: 'faz' } })).toBe('/v1/foo?filter=bar=baz&far=faz&exclude=metadata.managedFields');
     });
+    it('returns a string with a labelSelector and formatted for steve if the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { labelSelector: 'a=b' })).toBe('/v1/foo?labelSelector=a=b&exclude=metadata.managedFields');
+    });
+    it('returns a string with a labelSelector and filter, and formatted for steve if the url starts with "/v1"', () => {
+      expect(urlOptionsGetter('/v1/foo', { labelSelector: 'a=b', filter: { bar: 'baz', far: 'faz' } })).toBe('/v1/foo?labelSelector=a=b&filter=bar=baz&far=faz&exclude=metadata.managedFields');
+    });
     it('returns a string with an exclude statement for "bar" and "metadata.managedFields" if excludeFields is a single element array with the string "bar" and the url starts with "/v1/"', () => {
       expect(urlOptionsGetter('/v1/foo', { excludeFields: ['bar'] })).toBe('/v1/foo?exclude=bar&exclude=metadata.managedFields');
     });

package/plugins/steve/__tests__/resource-utils.test.ts

@@ -0,0 +1,159 @@
+import { steveCleanForDownload } from '@shell/plugins/steve/resource-utils';
+
+describe('steve: ressource-utils', () => {
+  it('should do nothing if the yaml is not passed', () => {
+    const r = steveCleanForDownload();
+
+    expect(r).toBeUndefined();
+  });
+  it('should remove all default rootKeys', () => {
+    const expectedYamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+`;
+    const yamlStr = `
+id: test_id
+links: 
+  view: https://example.com2
+type: test_type
+actions:
+  remove: https://example.com
+${ expectedYamlStr }
+`;
+    const cleanedYamlStr = steveCleanForDownload(yamlStr);
+
+    expect(cleanedYamlStr).toBe(expectedYamlStr);
+  });
+  it('should remove all the specified root keys', () => {
+    const part = `apiVersion: v1
+kind: Secret
+metadata:
+  name: my-secret`;
+
+    const rootKeyToYamlStringMap = {
+      id:    'id: test_id',
+      links: `links:
+  view: https://example.com`,
+      actions: `actions:
+  remove: https://example.com`,
+      type: 'type: Opaque'
+    };
+
+    const entries = Object.entries(rootKeyToYamlStringMap);
+    const yamlStr = `${ part }
+${ entries.map(([_, str]) => str).join('\n') }`;
+
+    entries.forEach(([key, str]) => {
+      const expectedYamlStr = `${ part }
+${ entries.filter(([k]) => k !== key).map(([_, str]) => str).join('\n') }\n`;
+      const cleanedYamlStr = steveCleanForDownload(yamlStr, { rootKeys: [key] });
+
+      expect(cleanedYamlStr).toBe(expectedYamlStr);
+    });
+  });
+  it('should remove all default metadata keys', () => {
+    const expectedYamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+`;
+    const yamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+  fields: 
+    - kube-root-ca.crt
+    - 1
+    - 7d23h
+  relationships:
+    - rel: 'owner'
+  state: 'active'
+`;
+    const cleanedYamlStr = steveCleanForDownload(yamlStr);
+
+    expect(cleanedYamlStr).toBe(expectedYamlStr);
+  });
+
+  it('should remove all the specified metadata keys', () => {
+    const part = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap`;
+
+    const metadataKeyToYamlStringMap = {
+      fields:
+`  fields:
+    - kube-root-ca.crt
+    - 1
+    - 7d23h`,
+      relationships:
+`  relationships:
+    - rel: owner`,
+      state: `  state: active`
+    };
+
+    const entries = Object.entries(metadataKeyToYamlStringMap);
+    const yamlStr = `${ part }
+${ entries.map(([_, str]) => str).join('\n') }`;
+
+    entries.forEach(([key, str]) => {
+      const expectedYamlStr = `${ part }
+${ entries.filter(([k]) => k !== key).map(([_, str]) => str).join('\n') }\n`;
+      const cleanedYamlStr = steveCleanForDownload(yamlStr, { metadataKeys: [key] });
+
+      expect(cleanedYamlStr).toBe(expectedYamlStr);
+    });
+  });
+  it('should remove all defalut condition keys', () => {
+    const expectedYamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+status:
+  conditions:
+    - {}
+    - {}
+    - message: message
+`;
+    const yamlStr = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+status:
+  conditions:
+    - error: 'error'
+    - transitioning: false
+    - message: message
+`;
+    const cleanedYamlStr = steveCleanForDownload(yamlStr);
+
+    expect(cleanedYamlStr).toBe(expectedYamlStr);
+  });
+  it('should remove all the specified condition keys', () => {
+    const part = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: my-configmap
+status:
+  conditions:
+    - message: message`;
+
+    const conditionKeyToYamlStringMap = {
+      error:         '    - error: error',
+      transitioning: '    - transitioning: false'
+    };
+
+    const entries = Object.entries(conditionKeyToYamlStringMap);
+    const yamlStr = `${ part }
+${ entries.map(([_, str]) => str).join('\n') }`;
+
+    entries.forEach(([key, str]) => {
+      const expectedYamlStr = `${ part }
+${ entries.map(([k, str]) => k === key ? '    - {}' : str).join('\n') }\n`;
+      const cleanedYamlStr = steveCleanForDownload(yamlStr, { conditionKeys: [key] });
+
+      expect(cleanedYamlStr).toBe(expectedYamlStr);
+    });
+  });
+});

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 {
 
@@ -330,31 +330,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 +374,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

@@ -33,6 +33,12 @@ export default {
     const parsedUrl = parse(url);
     const isSteve = steveRegEx.test(parsedUrl.path);
 
+    // labelSelector
+    if ( opt.labelSelector ) {
+      url += `${ url.includes('?') ? '&' : '?' }labelSelector=${ opt.labelSelector }`;
+    }
+    // End: labelSelector
+
     // Filter
     if ( opt.filter ) {
       url += `${ (url.includes('?') ? '&' : '?') }`;

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);
+}