@rancher/shell 0.2.5 → 0.3.1

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

@@ -25,6 +25,7 @@ import {
   validateLength,
 } from '@shell/utils/validators';
 import formRulesGenerator from '@shell/utils/validators/formRules/index';
+import { waitFor } from '@shell/utils/async';
 import jsyaml from 'js-yaml';
 import compact from 'lodash/compact';
 import forIn from 'lodash/forIn';
@@ -147,7 +148,7 @@ export const STATES_ENUM = {
   STOPPING:         'stopping',
   SUCCEEDED:        'succeeded',
   SUCCESS:          'success',
-  SUCCESSFUL:          'successful',
+  SUCCESSFUL:       'successful',
   SUPERSEDED:       'superseded',
   SUSPENDED:        'suspended',
   UNAVAILABLE:      'unavailable',
@@ -164,274 +165,274 @@ export const STATES_ENUM = {
 };
 
 export const STATES = {
-  [STATES_ENUM.IN_USE]:           {
+  [STATES_ENUM.IN_USE]: {
     color: 'success', icon: 'dot-open', label: 'In Use', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.IN_PROGRESS]:      {
+  [STATES_ENUM.IN_PROGRESS]: {
     color: 'info', icon: 'tag', label: 'In Progress', compoundIcon: 'info'
   },
   [STATES_ENUM.PENDING_ROLLBACK]: {
     color: 'info', icon: 'dot-half', label: 'Pending Rollback', compoundIcon: 'info'
   },
-  [STATES_ENUM.PENDING_UPGRADE]:  {
+  [STATES_ENUM.PENDING_UPGRADE]: {
     color: 'info', icon: 'dot-half', label: 'Pending Update', compoundIcon: 'info'
   },
-  [STATES_ENUM.ABORTED]:            {
+  [STATES_ENUM.ABORTED]: {
     color: 'warning', icon: 'error', label: 'Aborted', compoundIcon: 'warning'
   },
-  [STATES_ENUM.ACTIVATING]:         {
+  [STATES_ENUM.ACTIVATING]: {
     color: 'info', icon: 'tag', label: 'Activating', compoundIcon: 'info'
   },
-  [STATES_ENUM.ACTIVE]:             {
+  [STATES_ENUM.ACTIVE]: {
     color: 'success', icon: 'dot-open', label: 'Active', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.AVAILABLE]:          {
+  [STATES_ENUM.AVAILABLE]: {
     color: 'success', icon: 'dot-open', label: 'Available', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.BACKED_UP]:           {
+  [STATES_ENUM.BACKED_UP]: {
     color: 'success', icon: 'backup', label: 'Backed Up', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.BOUND]:              {
+  [STATES_ENUM.BOUND]: {
     color: 'success', icon: 'dot', label: 'Bound', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.BUILDING]:           {
+  [STATES_ENUM.BUILDING]: {
     color: 'success', icon: 'dot-open', label: 'Building', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.COMPLETED]:          {
+  [STATES_ENUM.COMPLETED]: {
     color: 'success', icon: 'dot', label: 'Completed', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.CORDONED]:           {
+  [STATES_ENUM.CORDONED]: {
     color: 'info', icon: 'tag', label: 'Cordoned', compoundIcon: 'info'
   },
-  [STATES_ENUM.COUNT]:              {
+  [STATES_ENUM.COUNT]: {
     color: 'success', icon: 'dot-open', label: 'Count', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.CREATED]:            {
+  [STATES_ENUM.CREATED]: {
     color: 'info', icon: 'tag', label: 'Created', compoundIcon: 'info'
   },
-  [STATES_ENUM.CREATING]:           {
+  [STATES_ENUM.CREATING]: {
     color: 'info', icon: 'tag', label: 'Creating', compoundIcon: 'info'
   },
-  [STATES_ENUM.DEACTIVATING]:       {
+  [STATES_ENUM.DEACTIVATING]: {
     color: 'info', icon: 'adjust', label: 'Deactivating', compoundIcon: 'info'
   },
-  [STATES_ENUM.DEGRADED]:           {
+  [STATES_ENUM.DEGRADED]: {
     color: 'warning', icon: 'error', label: 'Degraded', compoundIcon: 'warning'
   },
-  [STATES_ENUM.DENIED]:             {
+  [STATES_ENUM.DENIED]: {
     color: 'error', icon: 'adjust', label: 'Denied', compoundIcon: 'error'
   },
-  [STATES_ENUM.DEPLOYED]:           {
+  [STATES_ENUM.DEPLOYED]: {
     color: 'success', icon: 'dot-open', label: 'Deployed', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.DISABLED]:           {
+  [STATES_ENUM.DISABLED]: {
     color: 'warning', icon: 'error', label: 'Disabled', compoundIcon: 'warning'
   },
-  [STATES_ENUM.DISCONNECTED]:       {
+  [STATES_ENUM.DISCONNECTED]: {
     color: 'warning', icon: 'error', label: 'Disconnected', compoundIcon: 'warning'
   },
-  [STATES_ENUM.DRAINED]:            {
+  [STATES_ENUM.DRAINED]: {
     color: 'info', icon: 'tag', label: 'Drained', compoundIcon: 'info'
   },
-  [STATES_ENUM.DRAINING]:           {
+  [STATES_ENUM.DRAINING]: {
     color: 'warning', icon: 'tag', label: 'Draining', compoundIcon: 'warning'
   },
-  [STATES_ENUM.ERR_APPLIED]:         {
+  [STATES_ENUM.ERR_APPLIED]: {
     color: 'error', icon: 'error', label: 'Error Applied', compoundIcon: 'error'
   },
-  [STATES_ENUM.ERROR]:              {
+  [STATES_ENUM.ERROR]: {
     color: 'error', icon: 'error', label: 'Error', compoundIcon: 'error'
   },
-  [STATES_ENUM.ERRORING]:           {
+  [STATES_ENUM.ERRORING]: {
     color: 'error', icon: 'error', label: 'Erroring', compoundIcon: 'error'
   },
-  [STATES_ENUM.ERRORS]:             {
+  [STATES_ENUM.ERRORS]: {
     color: 'error', icon: 'error', label: 'Errors', compoundIcon: 'error'
   },
-  [STATES_ENUM.EXPIRED]:            {
+  [STATES_ENUM.EXPIRED]: {
     color: 'warning', icon: 'error', label: 'Expired', compoundIcon: 'warning'
   },
-  [STATES_ENUM.FAIL]:               {
+  [STATES_ENUM.FAIL]: {
     color: 'error', icon: 'error', label: 'Fail', compoundIcon: 'error'
   },
-  [STATES_ENUM.FAILED]:             {
+  [STATES_ENUM.FAILED]: {
     color: 'error', icon: 'error', label: 'Failed', compoundIcon: 'error'
   },
-  [STATES_ENUM.HEALTHY]:            {
+  [STATES_ENUM.HEALTHY]: {
     color: 'success', icon: 'dot-open', label: 'Healthy', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.INACTIVE]:           {
+  [STATES_ENUM.INACTIVE]: {
     color: 'error', icon: 'dot', label: 'Inactive', compoundIcon: 'error'
   },
-  [STATES_ENUM.INITIALIZING]:       {
+  [STATES_ENUM.INITIALIZING]: {
     color: 'warning', icon: 'error', label: 'Initializing', compoundIcon: 'warning'
   },
-  [STATES_ENUM.INPROGRESS]:         {
+  [STATES_ENUM.INPROGRESS]: {
     color: 'info', icon: 'spinner', label: 'In Progress', compoundIcon: 'info'
   },
-  [STATES_ENUM.INFO]:         {
+  [STATES_ENUM.INFO]: {
     color: 'info', icon: 'info', label: 'Info', compoundIcon: 'info'
   },
-  [STATES_ENUM.LOCKED]:             {
+  [STATES_ENUM.LOCKED]: {
     color: 'warning', icon: 'adjust', label: 'Locked', compoundIcon: 'warning'
   },
-  [STATES_ENUM.MIGRATING]:          {
+  [STATES_ENUM.MIGRATING]: {
     color: 'info', icon: 'info', label: 'Migrated', compoundIcon: 'info'
   },
-  [STATES_ENUM.MISSING]:            {
+  [STATES_ENUM.MISSING]: {
     color: 'warning', icon: 'adjust', label: 'Missing', compoundIcon: 'warning'
   },
-  [STATES_ENUM.MODIFIED]:           {
+  [STATES_ENUM.MODIFIED]: {
     color: 'warning', icon: 'edit', label: 'Modified', compoundIcon: 'warning'
   },
-  [STATES_ENUM.NOT_APPLICABLE]:      {
+  [STATES_ENUM.NOT_APPLICABLE]: {
     color: 'warning', icon: 'tag', label: 'Not Applicable', compoundIcon: 'warning'
   },
-  [STATES_ENUM.NOT_APLLIED]:         {
+  [STATES_ENUM.NOT_APLLIED]: {
     color: 'warning', icon: 'tag', label: 'Not Applied', compoundIcon: 'warning'
   },
-  [STATES_ENUM.NOT_READY]:           {
+  [STATES_ENUM.NOT_READY]: {
     color: 'warning', icon: 'tag', label: 'Not Ready', compoundIcon: 'warning'
   },
-  [STATES_ENUM.OFF]:                {
+  [STATES_ENUM.OFF]: {
     color: 'darker', icon: 'error', label: 'Off'
   },
-  [STATES_ENUM.ON_GOING]:           {
+  [STATES_ENUM.ON_GOING]: {
     color: 'info', icon: 'info', label: 'Info', compoundIcon: 'info'
   },
-  [STATES_ENUM.ORPHANED]:           {
+  [STATES_ENUM.ORPHANED]: {
     color: 'warning', icon: 'tag', label: 'Orphaned', compoundIcon: 'warning'
   },
-  [STATES_ENUM.OTHER]:              {
+  [STATES_ENUM.OTHER]: {
     color: 'info', icon: 'info', label: 'Other', compoundIcon: 'info'
   },
-  [STATES_ENUM.OUT_OF_SYNC]:          {
+  [STATES_ENUM.OUT_OF_SYNC]: {
     color: 'warning', icon: 'tag', label: 'Out Of Sync', compoundIcon: 'warning'
   },
-  [STATES_ENUM.PASS]:               {
+  [STATES_ENUM.PASS]: {
     color: 'success', icon: 'dot-dotfill', label: 'Pass', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.PASSED]:             {
+  [STATES_ENUM.PASSED]: {
     color: 'success', icon: 'dot-dotfill', label: 'Passed', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.PAUSED]:             {
+  [STATES_ENUM.PAUSED]: {
     color: 'info', icon: 'info', label: 'Paused', compoundIcon: 'info'
   },
-  [STATES_ENUM.PENDING]:            {
+  [STATES_ENUM.PENDING]: {
     color: 'info', icon: 'tag', label: 'Pending', compoundIcon: 'info'
   },
-  [STATES_ENUM.PROVISIONING]:       {
+  [STATES_ENUM.PROVISIONING]: {
     color: 'info', icon: 'dot', label: 'Provisioning', compoundIcon: 'info'
   },
-  [STATES_ENUM.PROVISIONED]:        {
+  [STATES_ENUM.PROVISIONED]: {
     color: 'success', icon: 'dot', label: 'Provisioned', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.PURGED]:             {
+  [STATES_ENUM.PURGED]: {
     color: 'error', icon: 'purged', label: 'Purged', compoundIcon: 'error'
   },
-  [STATES_ENUM.PURGING]:            {
+  [STATES_ENUM.PURGING]: {
     color: 'info', icon: 'purged', label: 'Purging', compoundIcon: 'info'
   },
-  [STATES_ENUM.READY]:              {
+  [STATES_ENUM.READY]: {
     color: 'success', icon: 'dot-open', label: 'Ready', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.RECONNECTING]:       {
+  [STATES_ENUM.RECONNECTING]: {
     color: 'error', icon: 'error', label: 'Reconnecting', compoundIcon: 'error'
   },
-  [STATES_ENUM.REGISTERING]:        {
+  [STATES_ENUM.REGISTERING]: {
     color: 'info', icon: 'tag', label: 'Registering', compoundIcon: 'info'
   },
-  [STATES_ENUM.REINITIALIZING]:     {
+  [STATES_ENUM.REINITIALIZING]: {
     color: 'warning', icon: 'error', label: 'Reinitializing', compoundIcon: 'warning'
   },
-  [STATES_ENUM.RELEASED]:           {
+  [STATES_ENUM.RELEASED]: {
     color: 'warning', icon: 'error', label: 'Released', compoundIcon: 'warning'
   },
-  [STATES_ENUM.REMOVED]:            {
+  [STATES_ENUM.REMOVED]: {
     color: 'error', icon: 'trash', label: 'Removed', compoundIcon: 'error'
   },
-  [STATES_ENUM.REMOVING]:           {
+  [STATES_ENUM.REMOVING]: {
     color: 'info', icon: 'trash', label: 'Removing', compoundIcon: 'info'
   },
-  [STATES_ENUM.REQUESTED]:          {
+  [STATES_ENUM.REQUESTED]: {
     color: 'info', icon: 'tag', label: 'Requested', compoundIcon: 'info'
   },
-  [STATES_ENUM.RESTARTING]:         {
+  [STATES_ENUM.RESTARTING]: {
     color: 'info', icon: 'adjust', label: 'Restarting', compoundIcon: 'info'
   },
-  [STATES_ENUM.RESTORING]:          {
+  [STATES_ENUM.RESTORING]: {
     color: 'info', icon: 'medicalcross', label: 'Restoring', compoundIcon: 'info'
   },
-  [STATES_ENUM.RESIZING]:           {
+  [STATES_ENUM.RESIZING]: {
     color: 'warning', icon: 'dot', label: 'Resizing', compoundIcon: 'warning'
   },
-  [STATES_ENUM.RUNNING]:            {
+  [STATES_ENUM.RUNNING]: {
     color: 'success', icon: 'dot-open', label: 'Running', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.SKIP]:               {
+  [STATES_ENUM.SKIP]: {
     color: 'info', icon: 'dot-open', label: 'Skip', compoundIcon: 'info'
   },
-  [STATES_ENUM.SKIPPED]:            {
+  [STATES_ENUM.SKIPPED]: {
     color: 'info', icon: 'dot-open', label: 'Skipped', compoundIcon: 'info'
   },
-  [STATES_ENUM.STARTING]:           {
+  [STATES_ENUM.STARTING]: {
     color: 'info', icon: 'adjust', label: 'Starting', compoundIcon: 'info'
   },
-  [STATES_ENUM.STOPPED]:            {
+  [STATES_ENUM.STOPPED]: {
     color: 'error', icon: 'dot', label: 'Stopped', compoundIcon: 'error'
   },
-  [STATES_ENUM.STOPPING]:           {
+  [STATES_ENUM.STOPPING]: {
     color: 'info', icon: 'adjust', label: 'Stopping', compoundIcon: 'info'
   },
-  [STATES_ENUM.SUCCEEDED]:          {
+  [STATES_ENUM.SUCCEEDED]: {
     color: 'success', icon: 'dot-dotfill', label: 'Succeeded', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.SUCCESS]:            {
+  [STATES_ENUM.SUCCESS]: {
     color: 'success', icon: 'dot-open', label: 'Success', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.SUCCESSFUL]:            {
+  [STATES_ENUM.SUCCESSFUL]: {
     color: 'success', icon: 'dot-open', label: 'Successful'
   },
-  [STATES_ENUM.SUPERSEDED]:         {
+  [STATES_ENUM.SUPERSEDED]: {
     color: 'info', icon: 'dot-open', label: 'Superseded', compoundIcon: 'info'
   },
-  [STATES_ENUM.SUSPENDED]:          {
+  [STATES_ENUM.SUSPENDED]: {
     color: 'info', icon: 'pause', label: 'Suspended', compoundIcon: 'info'
   },
-  [STATES_ENUM.UNAVAILABLE]:        {
+  [STATES_ENUM.UNAVAILABLE]: {
     color: 'error', icon: 'error', label: 'Unavailable', compoundIcon: 'error'
   },
-  [STATES_ENUM.UNHEALTHY]:          {
+  [STATES_ENUM.UNHEALTHY]: {
     color: 'error', icon: 'error', label: 'Unhealthy', compoundIcon: 'error'
   },
-  [STATES_ENUM.UNINSTALLED]:        {
+  [STATES_ENUM.UNINSTALLED]: {
     color: 'info', icon: 'trash', label: 'Uninstalled', compoundIcon: 'info'
   },
-  [STATES_ENUM.UNINSTALLING]:       {
+  [STATES_ENUM.UNINSTALLING]: {
     color: 'info', icon: 'trash', label: 'Uninstalling', compoundIcon: 'info'
   },
-  [STATES_ENUM.UNKNOWN]:            {
+  [STATES_ENUM.UNKNOWN]: {
     color: 'warning', icon: 'x', label: 'Unknown', compoundIcon: 'warning'
   },
-  [STATES_ENUM.UNTRIGGERED]:        {
+  [STATES_ENUM.UNTRIGGERED]: {
     color: 'success', icon: 'tag', label: 'Untriggered', compoundIcon: 'checkmark'
   },
-  [STATES_ENUM.UPDATING]:           {
+  [STATES_ENUM.UPDATING]: {
     color: 'warning', icon: 'tag', label: 'Updating', compoundIcon: 'warning'
   },
-  [STATES_ENUM.WAIT_APPLIED]:        {
+  [STATES_ENUM.WAIT_APPLIED]: {
     color: 'info', icon: 'tag', label: 'Wait Applied', compoundIcon: 'info'
   },
-  [STATES_ENUM.WAIT_CHECKIN]:        {
+  [STATES_ENUM.WAIT_CHECKIN]: {
     color: 'warning', icon: 'tag', label: 'Wait Checkin', compoundIcon: 'warning'
   },
-  [STATES_ENUM.WAITING]:            {
+  [STATES_ENUM.WAITING]: {
     color: 'info', icon: 'tag', label: 'Waiting', compoundIcon: 'info'
   },
-  [STATES_ENUM.WARNING]:            {
+  [STATES_ENUM.WARNING]: {
     color: 'warning', icon: 'error', label: 'Warning', compoundIcon: 'warning'
   },
-  [STATES_ENUM.DEPLOYING]:          {
+  [STATES_ENUM.DEPLOYING]: {
     color: 'info', icon: 'info', label: 'Deploying', compoundIcon: 'info'
   },
 };
@@ -464,7 +465,7 @@ const SORT_ORDER = {
   info:     3,
   success:  4,
   ready:    5,
-  notready:   6,
+  notready: 6,
   other:    7,
 };
 
@@ -752,41 +753,7 @@ export default class Resource {
   // ------------------------------------------------------------------
 
   waitForTestFn(fn, msg, timeoutMs, intervalMs) {
-    console.log('Starting wait for', msg); // eslint-disable-line no-console
-
-    if ( !timeoutMs ) {
-      timeoutMs = DEFAULT_WAIT_TMIMEOUT;
-    }
-
-    if ( !intervalMs ) {
-      intervalMs = DEFAULT_WAIT_INTERVAL;
-    }
-
-    return new Promise((resolve, reject) => {
-      // Do a first check immediately
-      if ( fn.apply(this) ) {
-        console.log('Wait for', msg, 'done immediately'); // eslint-disable-line no-console
-        resolve(this);
-      }
-
-      const timeout = setTimeout(() => {
-        console.log('Wait for', msg, 'timed out'); // eslint-disable-line no-console
-        clearInterval(interval);
-        clearTimeout(timeout);
-        reject(new Error(`Failed waiting for: ${ msg }`));
-      }, timeoutMs);
-
-      const interval = setInterval(() => {
-        if ( fn.apply(this) ) {
-          console.log('Wait for', msg, 'done'); // eslint-disable-line no-console
-          clearInterval(interval);
-          clearTimeout(timeout);
-          resolve(this);
-        } else {
-          console.log('Wait for', msg, 'not done yet'); // eslint-disable-line no-console
-        }
-      }, intervalMs);
-    });
+    return waitFor(() => fn.apply(this), msg, timeoutMs || DEFAULT_WAIT_TMIMEOUT, intervalMs || DEFAULT_WAIT_INTERVAL, true);
   }
 
   waitForState(state, timeout, interval) {
@@ -798,19 +765,19 @@ export default class Resource {
   waitForTransition() {
     return this.waitForTestFn(() => {
       return !this.transitioning;
-    }, 'transition completion');
+    }, 'transition completion', undefined, undefined);
   }
 
   waitForAction(name) {
     return this.waitForTestFn(() => {
       return this.hasAction(name);
-    }, `action=${ name }`);
+    }, `action=${ name }`, undefined, undefined);
   }
 
   waitForLink(name) {
     return this.waitForTestFn(() => {
       return this.hasLink(name);
-    }, `link=${ name }`);
+    }, `link=${ name }`, undefined, undefined);
   }
 
   hasCondition(condition) {
@@ -890,7 +857,7 @@ export default class Resource {
         action:  this.canUpdate ? 'goToEdit' : 'goToViewConfig',
         label:   this.t(this.canUpdate ? 'action.edit' : 'action.view'),
         icon:    'icon icon-edit',
-        enabled:  this.canCustomEdit,
+        enabled: this.canCustomEdit,
       },
       {
         action:  this.canEditYaml ? 'goToEditYaml' : 'goToViewYaml',
@@ -902,7 +869,7 @@ export default class Resource {
         action:  (this.canCustomEdit ? 'goToClone' : 'cloneYaml'),
         label:   this.t('action.clone'),
         icon:    'icon icon-copy',
-        enabled:  this.canClone && this.canCreate && (this.canCustomEdit || this.canYaml),
+        enabled: this.canClone && this.canCreate && (this.canCustomEdit || this.canYaml),
       },
       { divider: true },
       {
@@ -918,7 +885,7 @@ export default class Resource {
         action:  'viewInApi',
         label:   this.t('action.viewInApi'),
         icon:    'icon icon-external-link',
-        enabled:  this.canViewInApi,
+        enabled: this.canViewInApi,
       },
       {
         action:     'promptRemove',
@@ -1075,6 +1042,12 @@ export default class Resource {
     return this._save(...arguments);
   }
 
+  /**
+   * Allow to handle the response of the save request
+   * @param {*} res Full request response
+   */
+  processSaveResponse(res) { }
+
   async _save(opt = {}) {
     delete this.__rehydrate;
     delete this.__clone;
@@ -1151,6 +1124,9 @@ export default class Resource {
     try {
       const res = await this.$dispatch('request', { opt, type: this.type } );
 
+      // Allow to process response independently from the related models
+      this.processSaveResponse(res);
+
       // Steve sometimes returns Table responses instead of the resource you just saved.. ignore
       if ( res && res.kind !== 'Table') {
         await this.$dispatch('load', { data: res, existing: (forNew ? this : undefined ) });
@@ -1213,9 +1189,9 @@ export default class Resource {
     return {
       name:   `c-cluster-product-resource`,
       params: {
-        product:   this.$rootGetters['productId'],
-        cluster:   this.$rootGetters['clusterId'],
-        resource:  this.type,
+        product:  this.$rootGetters['productId'],
+        cluster:  this.$rootGetters['clusterId'],
+        resource: this.type,
       }
     };
   }
@@ -1276,7 +1252,7 @@ export default class Resource {
 
     location.query = {
       ...location.query,
-      [MODE]:  _VIEW,
+      [MODE]: _VIEW,
       [AS]:   _CONFIG,
       ...moreQuery
     };
@@ -1323,8 +1299,9 @@ export default class Resource {
 
   async download() {
     const value = await this.followLink('view', { headers: { accept: 'application/yaml' } });
+    const data = await this.$dispatch('cleanForDownload', value.data);
 
-    downloadFile(`${ this.nameDisplay }.yaml`, value.data, 'application/yaml');
+    downloadFile(`${ this.nameDisplay }.yaml`, data, 'application/yaml');
   }
 
   async downloadBulk(items) {
@@ -1343,8 +1320,11 @@ export default class Resource {
     }
 
     await eachLimit(items, 10, (item, idx) => {
-      return item.followLink('view', { headers: { accept: 'application/yaml' } } ).then((data) => {
-        files[`resources/${ names[idx] }`] = data.data || data;
+      return item.followLink('view', { headers: { accept: 'application/yaml' } } ).then(async(data) => {
+        const yaml = data.data || data;
+        const cleanedYaml = await this.$dispatch('cleanForDownload', yaml);
+
+        files[`resources/${ names[idx] }`] = cleanedYaml;
       });
     });
 
@@ -1468,13 +1448,13 @@ export default class Resource {
 
     if ( isCreate ) {
       res = await this.schema.followLink('collection', {
-        method:  'POST',
+        method: 'POST',
         headers,
         data:   yaml
       });
     } else {
       res = await this.followLink('update', {
-        method:  'PUT',
+        method: 'PUT',
         headers,
         data:   yaml
       });

package/plugins/steve/actions.js

@@ -7,6 +7,7 @@ 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';
 
 export default {
 
@@ -323,6 +324,35 @@ export default {
 
     return resource;
   },
+
+  // 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);
+  }
 };
 
 const diffRootKeys = [

package/plugins/steve/caches/resourceCache.js

@@ -0,0 +1,60 @@
+import { SCHEMA, COUNT } from '@shell/config/types';
+import { keyFieldFor, normalizeType } from '@shell/plugins/dashboard-store/normalize';
+import { addSchemaIndexFields } from '@shell/plugins/steve/schema.utils';
+import { hashObj } from '@shell/utils/crypto/browserHashUtils';
+
+export default class ResourceCache {
+  resources = {};
+  type;
+  keyField;
+  constructor(type) {
+    this.type = normalizeType(type === 'counts' ? COUNT : type);
+    this.keyField = keyFieldFor(this.type);
+  }
+
+  load(collection = []) {
+    // console.time('startSchemaLoads!!!');
+    for (let i = 0; i < collection.length; i++) {
+      const resource = collection[i];
+
+      if ( this.type === SCHEMA ) {
+        addSchemaIndexFields(resource);
+      }
+      const id = resource[this.keyField];
+
+      // Store the hash instead of the whole object. This means longer load time be reduces memory footprint
+      // Perf Note: 3.328125 ms to load ~2500 schemas as objects into cache
+      // Perf Note: 67.450927734375 ms to load ~2500 schemas as hashes into cache
+      this.resources[id] = hashObj(resource);
+    }
+    // console.timeEnd('startSchemaLoads!!!');
+
+    return this;
+  }
+
+  change(resource, callback) {
+    if ( this.type === SCHEMA ) {
+      addSchemaIndexFields(resource);
+    }
+
+    const existingResourceHash = this.resources[resource[this.keyField]] || {};
+    const newResourceHash = hashObj(resource);
+
+    if (existingResourceHash !== newResourceHash) {
+      this.resources[resource[this.keyField]] = resource;
+      callback();
+    }
+  }
+
+  create(resource, callback) {
+    // ToDo: the logic for create is identical to change in these caches but the worker doesn't know that
+    this.change(resource, callback);
+  }
+
+  remove(id, callback) {
+    if (this.resources[id]) {
+      delete this.resources[id];
+      callback();
+    }
+  }
+}