@rancher/shell 0.4.0 → 0.5.1

package/mixins/brand.js

@@ -1,10 +1,10 @@
 import { mapGetters } from 'vuex';
 import { CATALOG, MANAGEMENT } from '@shell/config/types';
-import { getVendor } from '@shell/config/private-label';
 import { SETTING } from '@shell/config/settings';
 import { findBy } from '@shell/utils/array';
 import { createCssVars } from '@shell/utils/color';
 import { _ALL_IF_AUTHED } from '@shell/plugins/dashboard-store/actions';
+import { setTitle } from '@shell/config/private-label';
 
 const cspAdaptorApp = ['rancher-csp-adapter', 'rancher-csp-billing-adapter'];
 
@@ -116,6 +116,7 @@ export default {
       if (this.linkColor) {
         this.setCustomColor(this.linkColor, 'link');
       }
+      this.setBodyClass();
     },
 
     cspAdapter(neu) {
@@ -142,7 +143,15 @@ export default {
           }
         }
       }
+    },
+    brand() {
+      this.setBodyClass();
     }
+
+  },
+  mounted() {
+    this.setBodyClass();
+    setTitle();
   },
   methods: {
     setCustomColor(color, name = 'primary') {
@@ -159,47 +168,26 @@ export default {
       for (const prop in vars) {
         document.body.style.removeProperty(prop);
       }
-    }
-  },
-  head() {
-    let cssClass = `overflow-hidden dashboard-body`;
-    const out = {
-      bodyAttrs: { class: `theme-${ this.theme } ${ cssClass }` },
-      title:     getVendor(),
-    };
-
-    if (getVendor() === 'Harvester') {
-      const ico = require(`~shell/assets/images/pl/harvester.png`);
-
-      out.title = 'Harvester';
-      out.link = [{
-        hid:  'icon',
-        rel:  'icon',
-        type: 'image/x-icon',
-        href: ico
-      }];
-    }
-
-    let brandMeta;
-
-    if ( this.brand ) {
-      try {
-        brandMeta = require(`~shell/assets/brand/${ this.brand }/metadata.json`);
-      } catch {
-        return out;
+    },
+    setBodyClass() {
+      const body = document.getElementsByTagName('body')[0];
+      const cssClass = `overflow-hidden dashboard-body`;
+      let bodyClass = `theme-${ this.theme } ${ cssClass }`;
+
+      if ( this.brand ) {
+        try {
+          const brandMeta = require(`~shell/assets/brand/${ this.brand }/metadata.json`);
+
+          if (brandMeta?.hasStylesheet === 'true') {
+            bodyClass = `${ cssClass } ${ this.brand } theme-${ this.theme }`;
+          } else {
+            bodyClass = `theme-${ this.theme } overflow-hidden dashboard-body`;
+            this.$store.dispatch('prefs/setBrandStyle', this.theme === 'dark');
+          }
+        } catch {}
       }
+      body.className = bodyClass;
     }
-
-    if (brandMeta?.hasStylesheet === 'true') {
-      cssClass = `${ cssClass } ${ this.brand } theme-${ this.theme }`;
-    } else {
-      cssClass = `theme-${ this.theme } overflow-hidden dashboard-body`;
-      this.$store.dispatch('prefs/setBrandStyle', this.theme === 'dark');
-    }
-
-    out.bodyAttrs.class = cssClass;
-
-    return out;
-  },
+  }
 
 };

package/mixins/labeled-form-element.ts

@@ -82,6 +82,11 @@ export default Vue.extend({
       type:      Array,
       // we only want functions in the rules array
       validator: (rules: any) => rules.every((rule: any) => ['function'].includes(typeof rule))
+    },
+
+    requireDirty: {
+      default: true,
+      type:    Boolean
     }
   },
 
@@ -141,7 +146,7 @@ export default Vue.extend({
           ruleMessages.push(message);
         }
       }
-      if (ruleMessages.length > 0 && (this.blurred || this.focused)) {
+      if (ruleMessages.length > 0 && (this.blurred || this.focused || !this.requireDirty)) {
         return ruleMessages.join(', ');
       } else {
         return undefined;

package/models/__tests__/management.cattle.io.node.ts

@@ -93,4 +93,89 @@ describe('class MgmtNode', () => {
       resetMocks();
     });
   });
+
+  describe('canScaleDown', () => {
+    const mgmtClusterId = 'test';
+    const nodeId = 'test/id';
+    const specs = {
+      worker: {
+        worker: true, etcd: false, controlPlane: false
+      },
+      etcd: {
+        worker: false, etcd: true, controlPlane: false
+      },
+      controlPlane: {
+        worker: false, etcd: false, controlPlane: true
+      },
+      etcdAndControlPlane: {
+        worker: false, etcd: true, controlPlane: true
+      },
+      all: {
+        worker: true, etcd: true, controlPlane: true
+      }
+    };
+
+    const workerNode = {
+      id:             '01',
+      isWorker:       true,
+      isControlPlane: false,
+      isEtcd:         false
+    };
+    const etcdNode = {
+      id:             '02',
+      isWorker:       false,
+      isControlPlane: false,
+      isEtcd:         true
+    };
+    const controlPlaneNode = {
+      id:             '03',
+      isWorker:       false,
+      isControlPlane: true,
+      isEtcd:         false
+    };
+    const etcdAndControlPlaneNode = {
+      id:             '03',
+      isWorker:       false,
+      isControlPlane: true,
+      isEtcd:         true
+    };
+    const allNode = {
+      id:             '04',
+      isWorker:       true,
+      isControlPlane: true,
+      isEtcd:         true
+    };
+
+    const baseCtx = {
+      rootGetters: {
+        'rancher/byId': () => ({ actions: { scaledown: 'scaledown' } }),
+        'i18n/t':       t
+      }
+    };
+
+    it.each([
+      [{ spec: specs.worker, nodes: [workerNode] }, true],
+      [{ spec: specs.etcd, nodes: [etcdNode, etcdNode, controlPlaneNode] }, true],
+      [{ spec: specs.etcdAndControlPlane, nodes: [etcdAndControlPlaneNode, etcdAndControlPlaneNode] }, true],
+      [{ spec: specs.etcdAndControlPlane, nodes: [etcdAndControlPlaneNode] }, false],
+      [{ spec: specs.all, nodes: [allNode] }, false],
+      [{ spec: specs.all, nodes: [allNode, allNode] }, true],
+    ])('should return canScaleDown properly', (data, expected) => {
+      const { spec, nodes } = data;
+      const mgmtNode = new MgmtNode({
+        spec,
+        id: nodeId
+      }, {
+        ...baseCtx,
+        getters: {
+          all: () => [{
+            mgmtClusterId,
+            nodes
+          }]
+        }
+      });
+
+      expect(mgmtNode.canScaleDown).toStrictEqual(expected);
+    });
+  });
 });

package/models/__tests__/management.cattle.io.nodepool.ts

@@ -0,0 +1,83 @@
+import MgmtNodePool from '@shell/models/management.cattle.io.nodepool';
+
+describe('class MgmtNodePool', () => {
+  describe('canScaleDownPool', () => {
+    const mgmtClusterId = 'test';
+    const nodeId = 'test/id';
+    const specs = {
+      worker: {
+        worker: true, etcd: false, controlPlane: false
+      },
+      etcd: {
+        worker: false, etcd: true, controlPlane: false
+      },
+      controlPlane: {
+        worker: false, etcd: false, controlPlane: true
+      },
+      etcdAndControlPlane: {
+        worker: false, etcd: true, controlPlane: true
+      },
+      all: {
+        worker: true, etcd: true, controlPlane: true
+      }
+    };
+
+    const workerNode = {
+      id:             '01',
+      isWorker:       true,
+      isControlPlane: false,
+      isEtcd:         false
+    };
+    const etcdNode = {
+      id:             '02',
+      isWorker:       false,
+      isControlPlane: false,
+      isEtcd:         true
+    };
+    const controlPlaneNode = {
+      id:             '03',
+      isWorker:       false,
+      isControlPlane: true,
+      isEtcd:         false
+    };
+    const etcdAndControlPlaneNode = {
+      id:             '03',
+      isWorker:       false,
+      isControlPlane: true,
+      isEtcd:         true
+    };
+    const allNode = {
+      id:             '04',
+      isWorker:       true,
+      isControlPlane: true,
+      isEtcd:         true
+    };
+
+    const baseCtx = { rootGetters: { 'rancher/byId': () => ({ actions: { scaledown: 'scaledown' } }) } };
+
+    it.each([
+      [{ spec: specs.worker, nodes: [workerNode] }, true],
+      [{ spec: specs.etcd, nodes: [etcdNode, etcdNode, controlPlaneNode] }, true],
+      [{ spec: specs.etcdAndControlPlane, nodes: [etcdAndControlPlaneNode, etcdAndControlPlaneNode] }, true],
+      [{ spec: specs.etcdAndControlPlane, nodes: [etcdAndControlPlaneNode] }, false],
+      [{ spec: specs.all, nodes: [allNode] }, false],
+      [{ spec: specs.all, nodes: [allNode, allNode] }, true],
+    ])('should return canScaleDownPool properly', (data, expected) => {
+      const { spec, nodes } = data;
+      const mgmtNode = new MgmtNodePool({
+        spec,
+        id: nodeId
+      }, {
+        ...baseCtx,
+        getters: {
+          all: () => [{
+            mgmtClusterId,
+            nodes
+          }]
+        }
+      });
+
+      expect(mgmtNode.canScaleDownPool()).toStrictEqual(expected);
+    });
+  });
+});

package/models/__tests__/namespace.test.ts

@@ -1,11 +1,48 @@
 import Namespace from '@shell/models/namespace';
+import { SYSTEM_NAMESPACE } from '@shell/config/labels-annotations';
+import SYSTEM_NAMESPACES from '@shell/config/system-namespaces';
 
 describe('class Namespace', () => {
   describe('checking if isSystem', () => {
     it.each([
-      ['c-whatever-system', true],
-      ['whatever', false]
-    ])('should return true if end with "-system', (name, expectation) => {
+      ['whatever1', SYSTEM_NAMESPACE, true],
+      ['whatever2', 'any-annotation', false],
+      ['whatever3', '', false]
+    ])('should return true if it has the correct annotation', (name, annotation, expectation) => {
+      const namespace = new Namespace({});
+
+      namespace.metadata = { ...namespace.metadata, name };
+
+      if (annotation) {
+        namespace.metadata.annotations = { [annotation]: 'true' };
+      }
+
+      expect(namespace.isSystem).toBe(expectation);
+    });
+
+    const assertionsArr = [];
+
+    SYSTEM_NAMESPACES.forEach((ns) => {
+      assertionsArr.push([ns, true]);
+    });
+
+    assertionsArr.push(['c-whatever-system', false]);
+    assertionsArr.push(['cattle-whatever', false]);
+    assertionsArr.push(['', false]);
+
+    it.each(assertionsArr)('should return true if it belongs to the curated list of namespaces', (name, expectation) => {
+      const namespace = new Namespace({});
+
+      namespace.metadata = { ...namespace.metadata, name };
+
+      expect(namespace.isSystem).toBe(expectation);
+    });
+
+    it.each([
+      ['cattle-c-whatever-system', true],
+      ['cattle-whatever', false],
+      ['c-whatever-system', false]
+    ])('should return true if starts with "cattle-" end with "-system', (name, expectation) => {
       const namespace = new Namespace({});
 
       namespace.metadata = { ...namespace.metadata, name };
@@ -18,18 +55,21 @@ describe('class Namespace', () => {
 
   describe('checking if isObscure', () => {
     it.each([
-      ['c-whatever-system', true],
-      ['whatever', false],
-      ['', false]
-    ])('should return a value if has or not a name in the metadata', (name, expectation) => {
+      ['c-whatever-system', 'management.cattle.io/system-namespace', true],
+      ['p-whatever', SYSTEM_NAMESPACE, true],
+      ['p-whatever', '', false],
+      ['', '', false]
+    ])('should return a value if is system AND has the correct prefix', (name, annotation, expectation) => {
       const namespace = new Namespace({});
 
       namespace.metadata = { ...namespace.metadata, name };
 
+      if (annotation) {
+        namespace.metadata.annotations = { [annotation]: 'true' };
+      }
+
       expect(namespace.isObscure).toBe(expectation);
     });
-
-    it.todo('should return a value if is or not system');
   });
 
   it.each([

package/models/__tests__/workload.test.ts

@@ -0,0 +1,91 @@
+import Workload from '@shell/models/workload.js';
+import { steveClassJunkObject } from '@shell/plugins/steve/__tests__/utils/steve-mocks';
+
+describe('class: Workload', () => {
+  describe('given custom workload keys', () => {
+    const customContainerImage = 'image';
+    const customContainer = {
+      image:    customContainerImage,
+      __active: 'whatever',
+      active:   'whatever',
+      _init:    'whatever',
+      error:    'whatever',
+    };
+    const customWorkload = {
+      ...steveClassJunkObject,
+      type:        '123abv',
+      __rehydrate: 'whatever',
+      __clone:     'whatever',
+      spec:        {
+        template: {
+          spec: {
+            containers:     [customContainer],
+            initContainers: [customContainer],
+          }
+        }
+      }
+    };
+
+    customWorkload.metadata.name = 'abc';
+
+    it('should keep internal keys', () => {
+      const workload = new Workload(customWorkload, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': jest.fn() },
+      });
+
+      expect({ ...workload }).toStrictEqual(customWorkload);
+    });
+
+    describe('method: save', () => {
+      it('should remove all the internal keys', async() => {
+        const dispatch = jest.fn();
+        const workload = new Workload(customWorkload, {
+          getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+          dispatch,
+          rootGetters: {
+            'i18n/t':      jest.fn(),
+            'i18n/exists': () => true,
+          },
+        });
+        const expectation = {
+          metadata: {
+            name:                       'abc',
+            fields:                     'whatever',
+            resourceVersion:            'whatever',
+            clusterName:                'whatever',
+            deletionGracePeriodSeconds: 'whatever',
+            generateName:               'whatever',
+          },
+          spec: {
+            template: {
+              spec: {
+                containers:     [{ image: customContainerImage }],
+                initContainers: [{ image: customContainerImage }]
+              }
+            }
+          }
+        };
+
+        await workload.save();
+
+        const opt = {
+          data:    expectation,
+          headers: {
+            accept:         'application/json',
+            'content-type': 'application/json',
+          },
+          method: 'post',
+          url:    undefined,
+        };
+
+        // Data sent should have been cleaned
+        expect(dispatch).toHaveBeenCalledWith('request', { opt, type: customWorkload.type });
+
+        // Original workload model should remain unchanged
+        expect({ ...workload }).toStrictEqual(customWorkload);
+      });
+    });
+  });
+});

package/models/cluster/node.js

@@ -187,7 +187,7 @@ export default class ClusterNode extends SteveModel {
   }
 
   get cpuCapacity() {
-    return parseSi(this.status.allocatable.cpu);
+    return parseSi(this.status.allocatable?.cpu);
   }
 
   get cpuUsagePercentage() {
@@ -203,7 +203,7 @@ export default class ClusterNode extends SteveModel {
   }
 
   get ramCapacity() {
-    return parseSi(this.status.capacity.memory);
+    return parseSi(this.status.capacity?.memory);
   }
 
   get ramUsagePercentage() {
@@ -219,7 +219,7 @@ export default class ClusterNode extends SteveModel {
   }
 
   get podUsage() {
-    return calculatePercentage(this.status.allocatable.pods, this.status.capacity.pods);
+    return calculatePercentage(this.status.allocatable?.pods, this.status.capacity?.pods);
   }
 
   get podConsumedUsage() {
@@ -227,7 +227,7 @@ export default class ClusterNode extends SteveModel {
   }
 
   get podCapacity() {
-    return Number.parseInt(this.status.capacity.pods);
+    return Number.parseInt(this.status.capacity?.pods);
   }
 
   get podConsumed() {

package/models/cluster.x-k8s.io.machinedeployment.js

@@ -7,6 +7,7 @@ import { handleConflict } from '@shell/plugins/dashboard-store/normalize';
 import { MACHINE_ROLES } from '@shell/config/labels-annotations';
 import { notOnlyOfRole } from '@shell/models/cluster.x-k8s.io.machine';
 import { KIND } from '../config/elemental-types';
+import { KIND as HARVESTER_KIND } from '../config/harvester-manager-types';
 
 export default class CapiMachineDeployment extends SteveModel {
   get cluster() {
@@ -69,6 +70,19 @@ export default class CapiMachineDeployment extends SteveModel {
     return this.template?.providerSize || this.t('node.list.poolDescription.noSize');
   }
 
+  get providerSummary() {
+    if (this.template) {
+      switch (this.infrastructureRefKind) {
+      case HARVESTER_KIND.MACHINE_TEMPLATE:
+        return null;
+      default:
+        return `${ this.providerDisplay } \u2013  ${ this.providerLocation } / ${ this.providerSize } (${ this.providerName })`;
+      }
+    }
+
+    return null;
+  }
+
   get desired() {
     return this.spec?.replicas || 0;
   }

package/models/fleet.cattle.io.cluster.js

@@ -107,6 +107,10 @@ export default class FleetCluster extends SteveModel {
     return this.metadata?.labels?.[FLEET_LABELS.CLUSTER_DISPLAY_NAME] || this.metadata?.name || this.id;
   }
 
+  get name() {
+    return this.metadata?.name || this.metadata?.labels?.[FLEET_LABELS.CLUSTER_NAME];
+  }
+
   get state() {
     if (this.spec?.paused === true) {
       return 'paused';

package/models/fleet.cattle.io.gitrepo.js

@@ -7,7 +7,9 @@ import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
 import { addObject, addObjects, findBy, insertAt } from '@shell/utils/array';
 import { set } from '@shell/utils/object';
 import SteveModel from '@shell/plugins/steve/steve-class';
-import { STATES_ENUM, colorForState, stateDisplay, stateSort } from '@shell/plugins/dashboard-store/resource-class';
+import {
+  STATES_ENUM, colorForState, mapStateToEnum, primaryDisplayStatusFromCount, stateDisplay, stateSort
+} from '@shell/plugins/dashboard-store/resource-class';
 import { NAME } from '@shell/config/product/explorer';
 
 function quacksLikeAHash(str) {
@@ -203,17 +205,6 @@ export default class GitRepo extends SteveModel {
     return hash;
   }
 
-  get clusterInfo() {
-    const ready = this.status?.readyClusters || 0;
-    const total = this.status?.desiredReadyClusters || 0;
-
-    return {
-      ready,
-      unready: total - ready,
-      total,
-    };
-  }
-
   get targetInfo() {
     let mode = null;
     let cluster = null;
@@ -384,8 +375,9 @@ export default class GitRepo extends SteveModel {
           namespace:              r.namespace,
           name:                   r.name,
           clusterId:              c.id,
+          clusterLabel:           c.metadata.labels[FLEET_ANNOTATIONS.CLUSTER_NAME],
           clusterName:            c.nameDisplay,
-          state,
+          state:                  mapStateToEnum(state),
           stateBackground:        color,
           stateDisplay:           display,
           stateSort:              stateSort(color, display),
@@ -401,6 +393,57 @@ export default class GitRepo extends SteveModel {
     return out;
   }
 
+  get clusterInfo() {
+    const ready = this.status?.readyClusters || 0;
+    const total = this.status?.desiredReadyClusters || 0;
+
+    return {
+      ready,
+      unready: total - ready,
+      total,
+    };
+  }
+
+  get clusterResourceStatus() {
+    const clusterStatuses = this.resourcesStatuses.reduce((prev, curr) => {
+      const { clusterId, clusterLabel } = curr;
+
+      const state = curr.state;
+
+      if (!prev[clusterId]) {
+        prev[clusterId] = {
+          clusterLabel,
+          resourceCounts: { [state]: 0, desiredReady: 0 }
+
+        };
+      }
+
+      if (!prev[clusterId].resourceCounts[state]) {
+        prev[clusterId].resourceCounts[state] = 0;
+      }
+
+      prev[clusterId].resourceCounts[state] += 1;
+      prev[clusterId].resourceCounts.desiredReady += 1;
+
+      return prev;
+    }, {});
+
+    const values = Object.keys(clusterStatuses).map((key) => {
+      const { clusterLabel, resourceCounts } = clusterStatuses[key];
+
+      return {
+        clusterId: key,
+        clusterLabel, // FLEET LABEL
+        status:    {
+          displayStatus:  primaryDisplayStatusFromCount(resourceCounts),
+          resourceCounts: { ...resourceCounts }
+        }
+      };
+    });
+
+    return values;
+  }
+
   get clustersList() {
     return this.$getters['all'](FLEET.CLUSTER);
   }

package/models/management.cattle.io.kontainerdriver.js

@@ -1,6 +1,6 @@
 import HybridModel from '@shell/plugins/steve/hybrid-class';
 
-const HIDDEN = ['rke', 'rancherkubernetesengine'];
+const HIDDEN = ['rke', 'rancherkubernetesengine', 'azureaks'];
 const V2 = ['amazoneks', 'googlegke', 'azureaks'];
 const IMPORTABLE = ['amazoneks', 'googlegke', 'azureaks'];