@rancher/shell 0.2.5 → 0.3.1

package/mixins/resource-fetch.js

@@ -1,11 +1,15 @@
 import { mapGetters } from 'vuex';
 import { COUNT, MANAGEMENT } from '@shell/config/types';
 import { SETTING, DEFAULT_PERF_SETTING } from '@shell/config/settings';
+import ResourceFetchNamespaced from '@shell/mixins/resource-fetch-namespaced';
 
 // Number of pages to fetch when loading incrementally
 const PAGES = 4;
 
 export default {
+
+  mixins: [ResourceFetchNamespaced],
+
   data() {
     // fetching the settings related to manual refresh from global settings
     const perfSetting = this.$store.getters['management/byId'](MANAGEMENT.SETTING, SETTING.UI_PERFORMANCE);
@@ -24,16 +28,21 @@ export default {
     return {
       perfConfig,
       init:                       false,
-      counts:                     {},
       multipleResources:          [],
+      loadResources:              [this.resource],
       // manual refresh vars
-      hasManualRefresh:            false,
+      hasManualRefresh:           false,
       watch:                      true,
       isTooManyItemsToAutoUpdate: false,
       force:                      false,
       // incremental loading vars
-      incremental:                0,
+      incremental:                false,
       fetchedResourceType:        [],
+      // force ns filtering
+      forceNsFilter:              {
+        ...perfConfig.forceNsFilter,
+        threshold: parseInt(perfConfig?.forceNsFilter?.threshold || '0', 10)
+      }
     };
   },
   beforeDestroy() {
@@ -42,10 +51,8 @@ export default {
       // clear up the store to make sure we aren't storing anything that might interfere with the next rendered list view
       this.$store.dispatch('resource-fetch/clearData');
 
-      const inStore = this.$store.getters['currentStore'](COUNT);
-
-      this.fetchedResourceType.forEach((type) => {
-        this.$store.dispatch(`${ inStore }/incrementLoadCounter`, type);
+      this.fetchedResourceType.forEach((item) => {
+        this.$store.dispatch(`${ item.currStore }/incrementLoadCounter`, item.type);
       });
     }
   },
@@ -53,15 +60,19 @@ export default {
   computed: {
     ...mapGetters({ refreshFlag: 'resource-fetch/refreshFlag' }),
     rows() {
-      const inStore = this.$store.getters['currentStore'](this.resource);
+      const currResource = this.fetchedResourceType.find(item => item.type === this.resource);
 
-      return this.$store.getters[`${ inStore }/all`](this.resource);
+      if (currResource) {
+        return this.$store.getters[`${ currResource.currStore }/all`](this.resource);
+      } else {
+        return [];
+      }
     },
     loading() {
       return this.rows.length ? false : this.$fetchState.pending;
     },
   },
-  watch:    {
+  watch: {
     refreshFlag(neu) {
       // this is where the data assignment will trigger the update of the list view...
       if (this.init && neu) {
@@ -69,12 +80,16 @@ export default {
       }
     }
   },
-  methods:  {
-    $fetchType(type, multipleResources = []) {
-      const inStore = this.$store.getters['currentStore'](COUNT);
-
+  methods: {
+    // this defines all the flags needed for the mechanism
+    // to work. They should be defined based on the main list view
+    // resource that is to be displayed. The secondary resources
+    // fetched should follow what was defined (if it is manual and/or incremental)
+    $initializeFetchData(type, multipleResources = [], storeType) {
       if (!this.init) {
-        this.__gatherResourceFetchData(type, multipleResources);
+        const currStore = storeType || this.$store.getters['currentStore']();
+
+        this.__gatherResourceFetchData(type, multipleResources, currStore);
 
         // make sure after init that, if we have a manual refresh, we always set the force = true
         if (!this.watch) {
@@ -85,31 +100,61 @@ export default {
           this.hasManualRefresh = true;
         }
       }
+    },
+    // data fetching for the mechanism
+    $fetchType(type, multipleResources = [], storeType) {
+      const currStore = storeType || this.$store.getters['currentStore']();
+
+      this.$initializeFetchData(type, multipleResources, currStore);
 
-      if (!this.fetchedResourceType.includes(type)) {
-        this.fetchedResourceType.push(type);
+      if (!this.fetchedResourceType.find(item => item.type === type)) {
+        this.fetchedResourceType.push({
+          type,
+          currStore
+        });
       }
 
-      return this.$store.dispatch(`${ inStore }/findAll`, {
+      let incremental = 0;
+
+      if (this.incremental) {
+        const resourceCount = this.__getCountForResources([type], this.namespaceFilter, currStore);
+
+        incremental = Math.ceil(resourceCount / PAGES);
+      }
+
+      const opt = {
+        incremental,
+        watch:            this.watch,
+        force:            this.force,
+        hasManualRefresh: this.hasManualRefresh
+      };
+
+      const schema = this.$store.getters[`${ currStore }/schemaFor`](type);
+
+      if (schema?.attributes?.namespaced) {
+        opt.namespaced = this.namespaceFilter;
+      }
+
+      return this.$store.dispatch(`${ currStore }/findAll`, {
         type,
-        opt: {
-          incremental:      this.incremental,
-          watch:            this.watch,
-          force:            this.force,
-          hasManualRefresh: this.hasManualRefresh
-        }
+        opt
       });
     },
-    __getCountForResource(resourceName) {
-      let resourceCount;
 
-      if (this.counts[`${ resourceName }`]) {
-        resourceCount = this.counts[`${ resourceName }`].summary?.count;
-      }
+    __getCountForResources(resourceNames, namespace, storeType) {
+      const currStore = storeType || this.$store.getters['currentStore']();
+
+      return resourceNames.reduce((res, type) => res + this.__getCountForResource(type, namespace, currStore), 0);
+    },
+
+    __getCountForResource(resourceName, namespace, storeType) {
+      const resourceCounts = this.$store.getters[`${ storeType }/all`](COUNT)[0]?.counts[`${ resourceName }`]; // NB `rancher` store behaves differently, lacks counts but has resource
+      const resourceCount = namespace && resourceCounts?.namespaces ? resourceCounts?.namespaces[namespace]?.count : resourceCounts?.summary?.count;
 
       return resourceCount || 0;
     },
-    __gatherResourceFetchData(type, multipleResources) {
+
+    __gatherResourceFetchData(resourceName, multipleResources, currStore) {
       // flag to prevent a first data update being triggered from the requestData watcher
       this.init = true;
 
@@ -123,8 +168,6 @@ export default {
 
       // other vars
       this.multipleResources = multipleResources;
-      const resourceName = type;
-      const inStore = this.$store.getters['currentStore'](resourceName);
       let resourceCount = 0;
 
       // manual refresh vars
@@ -132,30 +175,21 @@ export default {
       let isTooManyItemsToAutoUpdate = false;
 
       // incremental loading vars
-      let incremental = 0;
+      let incremental = false;
 
       // get resource counts
-      if ( this.$store.getters[`${ inStore }/haveAll`](COUNT) ) {
-        this.counts = this.$store.getters[`${ inStore }/all`](COUNT)[0].counts;
-
-        if (this.multipleResources.length) {
-          this.multipleResources.forEach((item) => {
-            resourceCount = resourceCount + this.__getCountForResource(item);
-          });
-        } else {
-          resourceCount = this.__getCountForResource(resourceName);
-        }
-      }
+      const resourcesForCount = this.multipleResources.length ? this.multipleResources : [resourceName];
+
+      resourceCount = this.__getCountForResources(resourcesForCount, this.namespaceFilter, currStore);
 
       // manual refresh check
       if (manualDataRefreshEnabled && resourceCount >= manualDataRefreshThreshold) {
         watch = false;
         isTooManyItemsToAutoUpdate = true;
       }
-      // manual refresh check
-      if (incrementalLoadingEnabled && incrementalLoadingThreshold > 0 && resourceCount >= incrementalLoadingThreshold) {
-        incremental = Math.ceil(resourceCount / PAGES);
-      }
+
+      // incremental loading check
+      incremental = incrementalLoadingEnabled && incrementalLoadingThreshold > 0 && resourceCount >= incrementalLoadingThreshold;
 
       // pass on the flag that controls the appearance of the manual refresh button on the sortable table
       this.$store.dispatch('resource-fetch/updateIsTooManyItems', isTooManyItemsToAutoUpdate);

package/mixins/resource-manager.js

@@ -6,7 +6,7 @@ export default {
   data() {
     return { isLoadingSecondaryResources: false };
   },
-  methods:  {
+  methods: {
     /**
     *
     * Function resourceManagerFetchSecondaryResources
@@ -35,11 +35,7 @@ export default {
           let url = schema.links.collection;
 
           if (schema?.attributes?.namespaced && namespace) {
-            const parts = url.split('/');
-
-            parts.splice(parts.length - 2, 0, `api`);
-            parts.splice(parts.length - 1, 0, `namespaces/${ namespace }`);
-            url = parts.join('/');
+            url = `${ url }/${ namespace }`;
           } else if (onlyNamespaced) {
             // Type isn't namespaced and we've been requested to only fetch namespaced types
             return;
@@ -60,30 +56,12 @@ export default {
           const status = hash[type].status;
           // if it's namespaced, we get the data on 'items' prop, for non-namespaced it's  'data' prop...
           const requestData = hash[type].value.items || hash[type].value.data || hash[type].value;
-          const schema = this.$store.getters['cluster/schemaFor'](type);
 
           if (status === 'fulfilled' && resourceData.data[type] && resourceData.data[type].applyTo?.length) {
             for (let y = 0; y < resourceData.data[type].applyTo.length; y++) {
               const apply = resourceData.data[type].applyTo[y];
               let resources = requestData;
 
-              if (schema?.attributes?.namespaced) {
-                // The resources returned when requesting namespaced types do not contain id, type and links properties.
-                // This isn't perfect, or universally applicable, but will work for the current set of use cases
-                // To make this more generic
-                // - id param = this.$store.getters['cluster/keyFieldForType'](type)
-                // - id value = new dashboard-store getter, overwritten by steve store getter
-                requestData.forEach((item) => {
-                  // if there's already a prop type, don't overwrite it without storing it first...
-                  // only do this operation once in multiple apply's because the requestData is the same!
-                  if (item.type && !item._type) {
-                    item._type = item.type;
-                  }
-                  item.type = type;
-                  item.id = `${ item.metadata.namespace }/${ item.metadata.name }`;
-                });
-              }
-
               if (apply.classify) {
                 resources = await this.$store.dispatch('cluster/createMany', requestData);
               }

package/models/apps.controllerrevision.js

@@ -0,0 +1,7 @@
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class ControllerRevision extends SteveModel {
+  get revisionNumber() {
+    return this.revision;
+  }
+}

package/models/apps.daemonset.js

@@ -1,4 +1,22 @@
 import Workload from './workload';
 
 export default class DaemonSet extends Workload {
+  async rollBack(cluster, daemonSet, revision) {
+    const body = [
+      {
+        op:    'replace',
+        path:  '/spec/template',
+        value: {
+          metadata: revision.data.spec.template.metadata,
+          spec:     revision.data.spec.template.spec
+        }
+      }, {
+        op:    'replace',
+        path:  '/metadata/generation',
+        value: revision.revision,
+      }
+    ];
+
+    await this.rollBackWorkload(cluster, daemonSet, 'daemonsets', body);
+  }
 }

package/models/apps.deployment.js

@@ -1,6 +1,15 @@
 import { WORKLOAD_TYPES } from '@shell/config/types';
 import Workload from './workload';
 
+const IGNORED_ANNOTATIONS = [
+  'kubectl.kubernetes.io/last-applied-configuration',
+  'deployment.kubernetes.io/revision',
+  'deployment.kubernetes.io/revision-history',
+  'deployment.kubernetes.io/desired-replicas',
+  'deployment.kubernetes.io/max-replicas',
+  'deprecated.deployment.rollback.to',
+];
+
 export default class Deployment extends Workload {
   get replicaSetId() {
     const set = this.metadata?.relationships?.find((relationship) => {
@@ -10,4 +19,39 @@ export default class Deployment extends Workload {
 
     return set?.toId?.replace(`${ this.namespace }/`, '');
   }
+
+  async rollBack(cluster, deployment, revision) {
+    const body = [
+      {
+        op:    'replace',
+        path:  '/spec/template',
+        value: {
+          metadata: {
+            creationTimestamp: null,
+            labels:            Object.keys(revision.spec.template.metadata?.labels || {}).reduce((prev, key) => {
+              if (key !== 'pod-template-hash') {
+                prev[key] = revision.spec.template.metadata.labels[key];
+              }
+
+              return prev;
+            }, {}),
+            annotations: Object.keys(revision.spec.template.metadata?.annotations || {}).reduce((prev, key) => {
+              if (!IGNORED_ANNOTATIONS.includes(key)) {
+                prev[key] = revision.spec.template.metadata.annotations[key];
+              }
+
+              return prev;
+            }, {}),
+          },
+          spec: revision.spec.template.spec
+        }
+      }, {
+        op:    'replace',
+        path:  '/metadata/annotations',
+        value: { 'deployment.kubernetes.io/revision': revision.metadata.annotations['deployment.kubernetes.io/revision'] }
+      }
+    ];
+
+    await this.rollBackWorkload(cluster, deployment, 'deployments', body);
+  }
 }

package/models/apps.replicaset.js

@@ -1,4 +1,11 @@
 import Workload from './workload';
 
 export default class ReplicaSet extends Workload {
+  get revisionNumber() {
+    if (!this.ownedByWorkload) {
+      return undefined;
+    }
+
+    return this.metadata.annotations['deployment.kubernetes.io/revision'];
+  }
 }

package/models/apps.statefulset.js

@@ -1,4 +1,22 @@
 import Workload from './workload';
 
 export default class StatefulSet extends Workload {
+  async rollBack(cluster, statefulSet, revision) {
+    const body = [
+      {
+        op:    'replace',
+        path:  '/spec/template',
+        value: {
+          metadata: revision.data.spec.template.metadata,
+          spec:     revision.data.spec.template.spec
+        }
+      }, {
+        op:    'replace',
+        path:  '/metadata/generation',
+        value: revision.revision,
+      }
+    ];
+
+    await this.rollBackWorkload(cluster, statefulSet, 'statefulsets', body);
+  }
 }

package/models/autoscaling.horizontalpodautoscaler.js

@@ -17,19 +17,19 @@ export default class HPA extends SteveModel {
     const { spec = {}, status } = this;
     const out = [
       {
-        label:     spec?.scaleTargetRef?.kind ?? this.t('hpa.tabs.workload'),
-        content:   spec?.scaleTargetRef?.name,
+        label:   spec?.scaleTargetRef?.kind ?? this.t('hpa.tabs.workload'),
+        content: spec?.scaleTargetRef?.name,
       },
       {
-        label:     this.t('hpa.workloadTab.min'),
+        label:   this.t('hpa.workloadTab.min'),
         content: spec?.minReplicas,
       },
       {
-        label:     this.t('hpa.workloadTab.max'),
+        label:   this.t('hpa.workloadTab.max'),
         content: spec?.maxReplicas,
       },
       {
-        label:     this.t('hpa.workloadTab.current'),
+        label:   this.t('hpa.workloadTab.current'),
         content: status?.currentReplicas ?? 0,
       },
       {

package/models/batch.cronjob.js

@@ -20,27 +20,27 @@ export default class CronJob extends Workload {
     const canRunNow = !!jobSchema?.collectionMethods.find(x => ['blocked-post', 'post'].includes(x.toLowerCase()));
 
     insertAt(out, 0, {
-      action:     'runNow',
-      label:      this.t('action.runNow'),
-      icon:       'icon icon-spinner',
-      enabled:    canRunNow,
-      bulkable:   true,
+      action:   'runNow',
+      label:    this.t('action.runNow'),
+      icon:     'icon icon-spinner',
+      enabled:  canRunNow,
+      bulkable: true,
     });
 
     insertAt(out, 1, {
-      action:     'suspend',
-      label:      this.t('action.suspend'),
-      icon:       'icon icon-pause',
-      enabled:    !suspended && this.canUpdate,
-      bulkable:   true,
+      action:   'suspend',
+      label:    this.t('action.suspend'),
+      icon:     'icon icon-pause',
+      enabled:  !suspended && this.canUpdate,
+      bulkable: true,
     });
 
     insertAt(out, 2, {
-      action:     'resume',
-      label:      this.t('action.resume'),
-      icon:       'icon icon-play',
-      enabled:    suspended && this.canUpdate,
-      bulkable:   true,
+      action:   'resume',
+      label:    this.t('action.resume'),
+      icon:     'icon icon-play',
+      enabled:  suspended && this.canUpdate,
+      bulkable: true,
     });
 
     return out;

package/models/batch.job.js

@@ -1,4 +1,19 @@
 import Workload from './workload';
+import { getSecondsDiff } from '@shell/utils/time';
 
 export default class Job extends Workload {
+  get duration() {
+    const schema = this.$getters['schemaFor'](this.type);
+    const rowValueGetter = this.$rootGetters['type-map/rowValueGetter'];
+
+    const { completionTime, startTime } = this.status;
+
+    const staticValue = schema && rowValueGetter ? rowValueGetter(schema, 'Duration')(this) : null;
+    const seconds = staticValue && startTime ? getSecondsDiff(startTime, completionTime || new Date()) : 0;
+
+    return {
+      value: completionTime ? { staticValue } : { startTime },
+      seconds,
+    };
+  }
 }

package/models/catalog.cattle.io.app.js

@@ -28,10 +28,10 @@ export default class CatalogApp extends SteveModel {
     const out = super._availableActions;
 
     const upgrade = {
-      action:     'goToUpgrade',
-      enabled:    true,
-      icon:       'icon icon-fw icon-edit',
-      label:      this.t('catalog.install.action.goToUpgrade'),
+      action:  'goToUpgrade',
+      enabled: true,
+      icon:    'icon icon-fw icon-edit',
+      label:   this.t('catalog.install.action.goToUpgrade'),
     };
 
     out.unshift(upgrade);
@@ -173,8 +173,8 @@ export default class CatalogApp extends SteveModel {
     this.currentRouter().push({
       name:   'c-cluster-apps-charts-install',
       params: {
-        product:   this.$rootGetters['productId'],
-        cluster:   this.$rootGetters['clusterId'],
+        product: this.$rootGetters['productId'],
+        cluster: this.$rootGetters['clusterId'],
       },
       query,
     });

package/models/catalog.cattle.io.clusterrepo.js

@@ -19,11 +19,11 @@ export default class ClusterRepo extends SteveModel {
     insertAt(out, 0, { divider: true });
 
     insertAt(out, 0, {
-      action:     'refresh',
-      label:      this.t('action.refresh'),
-      icon:       'icon icon-refresh',
-      enabled:    !!this.links.update,
-      bulkable:   true,
+      action:   'refresh',
+      label:    this.t('action.refresh'),
+      icon:     'icon icon-refresh',
+      enabled:  !!this.links.update,
+      bulkable: true,
     });
 
     return out;
@@ -127,8 +127,8 @@ export default class ClusterRepo extends SteveModel {
   get details() {
     return [
       {
-        label:     'Type',
-        content:   this.typeDisplay,
+        label:   'Type',
+        content: this.typeDisplay,
       },
       {
         label:         'Downloaded',

package/models/catalog.cattle.io.operation.js

@@ -15,11 +15,11 @@ export default class CatalogOperation extends SteveModel {
     }
 
     const openLogs = {
-      action:     'openLogs',
-      enabled:    true,
-      icon:       'icon icon-fw icon-chevron-right',
-      label:      this.t('action.openLogs'),
-      total:      1,
+      action:  'openLogs',
+      enabled: true,
+      icon:    'icon icon-fw icon-chevron-right',
+      label:   this.t('action.openLogs'),
+      total:   1,
     };
 
     insertAt(out, idx + 1, openLogs);

package/models/chart.js

@@ -20,10 +20,10 @@ export default class Chart extends SteveModel {
     }
 
     const out = {
-      [REPO_TYPE]:  this.repoType,
-      [REPO]:       this.repoName,
-      [CHART]:      this.chartName,
-      [VERSION]:    version,
+      [REPO_TYPE]: this.repoType,
+      [REPO]:      this.repoName,
+      [CHART]:     this.chartName,
+      [VERSION]:   version,
     };
 
     if ( from ) {

package/models/cis.cattle.io.clusterscan.js

@@ -22,19 +22,19 @@ export default class ClusterScan extends SteveModel {
     const t = this.$rootGetters['i18n/t'];
 
     const downloadReport = {
-      action:     'downloadLatestReport',
-      enabled:    this.hasReport,
-      icon:       'icon icon-fw icon-download',
-      label:      t('cis.downloadReport'),
-      total:      1,
+      action:  'downloadLatestReport',
+      enabled: this.hasReport,
+      icon:    'icon icon-fw icon-download',
+      label:   t('cis.downloadReport'),
+      total:   1,
     };
 
     const downloadAllReports = {
-      action:     'downloadAllReports',
-      enabled:    this.hasReport,
-      icon:       'icon icon-fw icon-download',
-      label:      t('cis.downloadAllReports'),
-      total:      1,
+      action:  'downloadAllReports',
+      enabled: this.hasReport,
+      icon:    'icon icon-fw icon-download',
+      label:   t('cis.downloadAllReports'),
+      total:   1,
     };
 
     if (this.hasReports) {