@rancher/shell 3.0.8 → 3.0.9-rc.2

package/mixins/chart.js

@@ -303,57 +303,6 @@ export default {
 
       this.fetchStoreChart();
 
-      if ( this.query.appNamespace && this.query.appName ) {
-        // First check the URL query for an app name and namespace.
-        // Use those values to check for a catalog app resource.
-        // If found, set the form to edit mode. If not, set the
-        // form to create mode.
-
-        try {
-          this.existing = await this.$store.dispatch('cluster/find', {
-            type: CATALOG.APP,
-            id:   `${ this.query.appNamespace }/${ this.query.appName }`,
-          });
-
-          await this.existing?.fetchValues(true);
-
-          this.mode = _EDIT;
-        } catch (e) {
-          this.mode = _CREATE;
-          this.existing = null;
-        }
-      } else if ( this.chart?.targetNamespace && this.chart?.targetName ) {
-        // If the app name and namespace values are not provided in the
-        // query, fall back on target values defined in the Helm chart itself.
-
-        // Ask to install a special chart with fixed namespace/name
-        // or edit it if there's an existing install.
-
-        try {
-          this.existing = await this.$store.dispatch('cluster/find', {
-            type: CATALOG.APP,
-            id:   `${ this.chart.targetNamespace }/${ this.chart.targetName }`,
-          });
-          this.mode = _EDIT;
-        } catch (e) {
-          this.mode = _CREATE;
-          this.existing = null;
-        }
-      } else if (this.chart) {
-        const matching = this.chart.matchingInstalledApps;
-
-        if (matching.length === 1) {
-          this.existing = matching[0];
-          this.mode = _EDIT;
-        } else {
-          this.mode = _CREATE;
-        }
-      } else {
-        // Regular create
-
-        this.mode = _CREATE;
-      }
-
       if ( !this.chart ) {
         return;
       }
@@ -418,6 +367,62 @@ export default {
 
         console.error('Unable to fetch VersionInfo: ', e); // eslint-disable-line no-console
       }
+
+      if ( this.query.appNamespace && this.query.appName ) {
+        // First check the URL query for an app name and namespace.
+        // Use those values to check for a catalog app resource.
+        // If found, set the form to edit mode. If not, set the
+        // form to create mode.
+
+        try {
+          this.existing = await this.$store.dispatch('cluster/find', {
+            type: CATALOG.APP,
+            id:   `${ this.query.appNamespace }/${ this.query.appName }`,
+          });
+
+          await this.existing?.fetchValues(true);
+
+          this.mode = _EDIT;
+        } catch (e) {
+          this.mode = _CREATE;
+          this.existing = null;
+        }
+      } else {
+        const targetNamespace = this.version?.annotations?.[CATALOG_ANNOTATIONS.NAMESPACE];
+        const targetName = this.version?.annotations?.[CATALOG_ANNOTATIONS.RELEASE_NAME];
+
+        if ( targetNamespace && targetName ) {
+          // If the app name and namespace values are not provided in the
+          // query, fall back on target values defined in the Helm chart itself.
+
+          // Ask to install a special chart with fixed namespace/name
+          // or edit it if there's an existing install.
+
+          try {
+            this.existing = await this.$store.dispatch('cluster/find', {
+              type: CATALOG.APP,
+              id:   `${ targetNamespace }/${ targetName }`,
+            });
+            this.mode = _EDIT;
+          } catch (e) {
+            this.mode = _CREATE;
+            this.existing = null;
+          }
+        } else if (this.chart) {
+          const matching = this.chart.matchingInstalledApps;
+
+          if (matching.length === 1) {
+            this.existing = matching[0];
+            this.mode = _EDIT;
+          } else {
+            this.mode = _CREATE;
+          }
+        } else {
+          // Regular create
+
+          this.mode = _CREATE;
+        }
+      }
     }, // End of fetchChart
 
     // Charts have an annotation that specifies any additional charts that should be installed at the same time eg CRDs

package/models/__tests__/catalog.cattle.io.app.test.ts

@@ -145,4 +145,37 @@ describe('class CatalogApp', () => {
       expect(catalogApp.upgradeAvailable).toBe(expected);
     });
   });
+
+  describe('valuesLoaded', () => {
+    it('should be false if data is missing (e.g. secret)', () => {
+      const catalogApp = new CatalogApp({});
+
+      jest.spyOn(catalogApp, '_secret', 'get').mockReturnValue(null);
+
+      expect(catalogApp.valuesLoaded).toBe(false);
+    });
+
+    it('should be false if part of the data is missing', () => {
+      const catalogApp = new CatalogApp({});
+
+      jest.spyOn(catalogApp, '_secret', 'get').mockReturnValue({ data: {} });
+
+      expect(catalogApp.valuesLoaded).toBe(false);
+    });
+
+    it('should be true if all required data is present', () => {
+      const catalogApp = new CatalogApp({});
+
+      jest.spyOn(catalogApp, '_secret', 'get').mockReturnValue({
+        data: {
+          release: {
+            config: { foo: 'bar' },
+            chart:  { values: { baz: 'qux' } }
+          }
+        }
+      });
+
+      expect(catalogApp.valuesLoaded).toBe(true);
+    });
+  });
 });

package/models/__tests__/workload.test.ts

@@ -1,5 +1,6 @@
 import Workload from '@shell/models/workload.js';
 import { steveClassJunkObject } from '@shell/plugins/steve/__tests__/utils/steve-mocks';
+import { WORKLOAD_TYPES, SERVICE } from '@shell/config/types';
 
 describe('class: Workload', () => {
   describe('given custom workload keys', () => {
@@ -89,4 +90,336 @@ describe('class: Workload', () => {
       });
     });
   });
+
+  describe('method: scale', () => {
+    it('should call scaleUp when isUp is true', async() => {
+      const scaleUpMock = jest.fn().mockResolvedValue(undefined);
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { replicas: 1 }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': jest.fn() },
+      });
+
+      workload.scaleUp = scaleUpMock;
+
+      await workload.scale(true);
+
+      expect(scaleUpMock).toHaveBeenCalledWith();
+    });
+
+    it('should call scaleDown when isUp is false', async() => {
+      const scaleDownMock = jest.fn().mockResolvedValue(undefined);
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     { replicas: 2 }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': jest.fn() },
+      });
+
+      workload.scaleDown = scaleDownMock;
+
+      await workload.scale(false);
+
+      expect(scaleDownMock).toHaveBeenCalledWith();
+    });
+
+    it('should dispatch growl error on failure', async() => {
+      const dispatchMock = jest.fn();
+      const scaleUpMock = jest.fn().mockRejectedValue(new Error('Scale failed'));
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test-workload', namespace: 'default' },
+        spec:     { replicas: 1 }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    dispatchMock,
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      workload.scaleUp = scaleUpMock;
+      workload.$store = { dispatch: dispatchMock };
+
+      await workload.scale(true);
+
+      expect(dispatchMock).toHaveBeenCalledWith(
+        'growl/fromError',
+        expect.objectContaining({
+          title: expect.stringContaining('workload.list.errorCannotScale'),
+          err:   expect.any(Error)
+        }),
+        { root: true }
+      );
+    });
+  });
+
+  describe('getter: relatedServices', () => {
+    it('should return services that match workload pods', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'my-service', namespace: 'default' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      jest.fn(),
+          'cluster/all': (type: string) => (type === SERVICE ? [mockService] : [])
+        },
+      });
+
+      // Mock pods getter
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const related = workload.relatedServices;
+
+      expect(related).toContain(mockService);
+    });
+
+    it('should not return services from different namespace', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'my-service', namespace: 'other-namespace' },
+        spec:     { selector: { app: 'my-app' } }
+      };
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      jest.fn(),
+          'cluster/all': (type: string) => (type === SERVICE ? [mockService] : [])
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const related = workload.relatedServices;
+
+      expect(related).toHaveLength(0);
+    });
+
+    it('should not return services with non-matching selectors', () => {
+      const mockPod = {
+        metadata: {
+          name: 'pod-1', namespace: 'default', labels: { app: 'my-app' }
+        }
+      };
+      const mockService = {
+        metadata: { name: 'my-service', namespace: 'default' },
+        spec:     { selector: { app: 'different-app' } }
+      };
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      jest.fn(),
+          'cluster/all': (type: string) => (type === SERVICE ? [mockService] : [])
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [mockPod] });
+
+      const related = workload.relatedServices;
+
+      expect(related).toHaveLength(0);
+    });
+  });
+
+  describe('getter: podsCard', () => {
+    it('should return card for Deployment type', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [] });
+      Object.defineProperty(workload, 'canUpdate', { get: () => true });
+
+      const card = workload.podsCard;
+
+      expect(card).not.toBeNull();
+      expect(card.props.title).toBe('component.resource.detail.card.podsCard.title');
+      expect(card.props.showScaling).toBe(true);
+    });
+
+    it('should return card for DaemonSet type without scaling', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DAEMON_SET,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [] });
+      Object.defineProperty(workload, 'canUpdate', { get: () => true });
+
+      const card = workload.podsCard;
+
+      expect(card).not.toBeNull();
+      expect(card.props.showScaling).toBe(false);
+    });
+
+    it('should return null for unsupported types like CronJob', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.CRON_JOB,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      const card = workload.podsCard;
+
+      expect(card).toBeNull();
+    });
+
+    it('should hide scaling when canUpdate is false', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [] });
+      Object.defineProperty(workload, 'canUpdate', { get: () => false });
+
+      const card = workload.podsCard;
+
+      expect(card.props.showScaling).toBe(false);
+    });
+  });
+
+  describe('getter: jobsCard', () => {
+    it('should return card for CronJob type', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.CRON_JOB,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      Object.defineProperty(workload, 'jobs', { get: () => [] });
+
+      const card = workload.jobsCard;
+
+      expect(card).not.toBeNull();
+      expect(card.props.title).toBe('component.resource.detail.card.jobsCard.title');
+      expect(card.props.showScaling).toBe(false);
+    });
+
+    it('should return null for non-CronJob types', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      const card = workload.jobsCard;
+
+      expect(card).toBeNull();
+    });
+  });
+
+  describe('getter: cards', () => {
+    it('should include podsCard for Deployment', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.DEPLOYMENT,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {},
+        status:   {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': () => []
+        },
+      });
+
+      Object.defineProperty(workload, 'pods', { get: () => [] });
+      Object.defineProperty(workload, 'canUpdate', { get: () => true });
+
+      const cards = workload.cards;
+
+      // Cards should include podsCard (not null), jobsCard (null for deployment), and _cards from parent
+      const nonNullCards = cards.filter((c: any) => c !== null);
+
+      expect(nonNullCards.length).toBeGreaterThanOrEqual(1);
+      expect(nonNullCards[0].props.title).toBe('component.resource.detail.card.podsCard.title');
+    });
+
+    it('should include jobsCard for CronJob', () => {
+      const workload = new Workload({
+        type:     WORKLOAD_TYPES.CRON_JOB,
+        metadata: { name: 'test', namespace: 'default' },
+        spec:     {},
+        status:   {}
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': () => []
+        },
+      });
+
+      Object.defineProperty(workload, 'jobs', { get: () => [] });
+
+      const cards = workload.cards;
+      const nonNullCards = cards.filter((c: any) => c !== null);
+
+      // Should have jobsCard and insight card from parent
+      const jobsCard = nonNullCards.find((c: any) => c.props.title === 'component.resource.detail.card.jobsCard.title');
+
+      expect(jobsCard).toBeDefined();
+    });
+  });
 });

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

@@ -442,6 +442,14 @@ export default class CatalogApp extends SteveModel {
     }
   }
 
+  /**
+   * Safely checks if the required data is loaded.
+   * This avoids the exceptions thrown by `values` and `chartValues` when the data (e.g. secret) is missing.
+   */
+  get valuesLoaded() {
+    return !!this._values && !!this._chartValues;
+  }
+
   /**
    * The user's helm values
    */

package/models/pod.js

@@ -46,6 +46,20 @@ export default class Pod extends WorkloadService {
     return this.$getters['byId'](NODE, this.spec.nodeName);
   }
 
+  get customValidationRules() {
+    const out = [
+      {
+        nullable:       false,
+        path:           'metadata.name',
+        required:       true,
+        translationKey: 'generic.name',
+        type:           'subDomain',
+      },
+    ];
+
+    return out;
+  }
+
   get _availableActions() {
     const out = super._availableActions;
 

package/models/secret.js

@@ -573,7 +573,7 @@ export default class Secret extends SteveModel {
       const id = this.id?.replace(/.*\//, '');
 
       return {
-        name:   `c-cluster-product-${ VIRTUAL_TYPES.PROJECT_SECRETS }-namespace-id`,
+        name:   `c-cluster-product-resource-namespace-id`,
         params: {
           product:   this.$rootGetters['productId'],
           cluster:   this.$rootGetters['clusterId'],

package/models/workload.js

@@ -3,10 +3,12 @@ import { CATTLE_PUBLIC_ENDPOINTS } from '@shell/config/labels-annotations';
 import { WORKLOAD_TYPES, SERVICE, POD } from '@shell/config/types';
 import { set } from '@shell/utils/object';
 import day from 'dayjs';
-import { convertSelectorObj, parse } from '@shell/utils/selector';
+import { convertSelectorObj, parse, matches } from '@shell/utils/selector';
 import { SEPARATOR } from '@shell/config/workload';
 import WorkloadService from '@shell/models/workload.service';
 import { matching } from '@shell/utils/selector-typed';
+import { defineAsyncComponent, markRaw } from 'vue';
+import { useResourceCardRow } from '@shell/components/Resource/Detail/Card/StateCard/composables';
 
 export const defaultContainer = {
   imagePullPolicy: 'Always',
@@ -179,6 +181,22 @@ export default class Workload extends WorkloadService {
     await this.save();
   }
 
+  async scale(isUp) {
+    try {
+      if (isUp) {
+        await this.scaleUp();
+      } else {
+        await this.scaleDown();
+      }
+    } catch (err) {
+      this.$store.dispatch('growl/fromError', {
+        title: this.t('workload.list.errorCannotScale', { direction: isUp ? 'up' : 'down', workloadName: this.name }),
+        err
+      },
+      { root: true });
+    }
+  }
+
   get state() {
     if ( this.spec?.paused === true ) {
       return 'paused';
@@ -665,32 +683,6 @@ export default class Workload extends WorkloadService {
     }).filter((x) => !!x);
   }
 
-  get jobGauges() {
-    const out = {
-      succeeded: { color: 'success', count: 0 }, running: { color: 'info', count: 0 }, failed: { color: 'error', count: 0 }
-    };
-
-    if (this.type === WORKLOAD_TYPES.CRON_JOB) {
-      this.jobs.forEach((job) => {
-        const { status = {} } = job;
-
-        out.running.count += status.active || 0;
-        out.succeeded.count += status.succeeded || 0;
-        out.failed.count += status.failed || 0;
-      });
-    } else if (this.type === WORKLOAD_TYPES.JOB) {
-      const { status = {} } = this;
-
-      out.running.count = status.active || 0;
-      out.succeeded.count = status.succeeded || 0;
-      out.failed.count = status.failed || 0;
-    } else {
-      return null;
-    }
-
-    return out;
-  }
-
   get currentRevisionNumber() {
     if (this.ownedByWorkload || this.kind === 'Job' || this.kind === 'CronJob') {
       return undefined;
@@ -731,4 +723,78 @@ export default class Workload extends WorkloadService {
 
     return val;
   }
+
+  get servicesInNamespace() {
+    return this.$rootGetters['cluster/all'](SERVICE).filter((s) => s.metadata.namespace === this.metadata.namespace);
+  }
+
+  get relatedServices() {
+    // Find Services that have selectors that match this workload's Pod(s).
+    return this.servicesInNamespace.filter((service) => {
+      const selector = service.spec.selector;
+
+      for (let i = 0; i < this.pods.length; i++) {
+        const pod = this.pods[i];
+
+        if (service.metadata?.namespace === this.metadata?.namespace && matches(pod, selector)) {
+          return true;
+        }
+      }
+
+      return false;
+    });
+  }
+
+  get resourcesCardRows() {
+    return [
+      useResourceCardRow(this.t('component.resource.detail.card.resourcesCard.rows.services'), this.relatedServices, undefined, undefined, '#services'),
+      ...this._resourcesCardRows,
+    ];
+  }
+
+  get podsCard() {
+    const supportedTypes = [WORKLOAD_TYPES.DEPLOYMENT, WORKLOAD_TYPES.DAEMON_SET, WORKLOAD_TYPES.JOB, WORKLOAD_TYPES.STATEFUL_SET];
+
+    if (!supportedTypes.includes(this.type)) {
+      return null;
+    }
+
+    const scalingTypes = [WORKLOAD_TYPES.DEPLOYMENT, WORKLOAD_TYPES.STATEFUL_SET];
+
+    return {
+      component: markRaw(defineAsyncComponent(() => import('@shell/components/Resource/Detail/Card/StatusCard/index.vue'))),
+      props:     {
+        title:       this.t('component.resource.detail.card.podsCard.title'),
+        resources:   this.pods,
+        showScaling: this.canUpdate && scalingTypes.includes(this.type),
+        onIncrease:  () => this.scale(true),
+        onDecrease:  () => this.scale(false)
+      }
+    };
+  }
+
+  get jobsCard() {
+    const supportedTypes = [WORKLOAD_TYPES.CRON_JOB];
+
+    if (!supportedTypes.includes(this.type)) {
+      return null;
+    }
+
+    return {
+      component: markRaw(defineAsyncComponent(() => import('@shell/components/Resource/Detail/Card/StatusCard/index.vue'))),
+      props:     {
+        title:       this.t('component.resource.detail.card.jobsCard.title'),
+        resources:   this.jobs,
+        showScaling: false,
+      }
+    };
+  }
+
+  get cards() {
+    return [
+      this.podsCard,
+      this.jobsCard,
+      ...this._cards
+    ];
+  }
 }