@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.4

package/core/types-provisioning.ts

@@ -41,7 +41,11 @@ export type ClusterDetailTabs = {
   /**
    * Kube conditions of the provisioning.cattle.io.cluster instance
    */
-  conditions: boolean
+  conditions: boolean,
+  /**
+   * RKE2 autoscaler
+   */
+  autoscaler: boolean
 };
 
 /**
@@ -86,6 +90,48 @@ export interface ClusterProvisionerContext {
   isView: boolean
 }
 
+/**
+ * Existing tabs to show or hide in the cluster's detail view
+ */
+export interface ClusterProvisionerDetailTabs {
+  /**
+   * CAPI machine pool tab
+   */
+  machines: boolean,
+  /**
+   * Mgmt node pool tab
+   */
+  nodes?: boolean,
+  /**
+   * RKE2 provisioning logs
+   */
+  logs: boolean,
+  /**
+   * RKE2 registration commands
+   */
+  registration: boolean,
+  /**
+   * RKE2 snapshots
+   */
+  snapshots: boolean,
+  /**
+   * Kube resources related to the instance of provisioning.cattle.io.cluster
+   */
+  related: boolean,
+  /**
+   * Kube events associated with the instance of provisioning.cattle.io.cluster
+   */
+  events: boolean,
+  /**
+   * Kube conditions of the provisioning.cattle.io.cluster instance
+   */
+  conditions: boolean,
+  /**
+   * RKE2 autoscaler
+   */
+  autoscaler?: boolean,
+}
+
 /**
  * Interface that a custom Cluster Provisioner should implement
  *
@@ -180,36 +226,7 @@ export interface IClusterProvisioner {
    *
    * `plugin.addTab(TabLocation.RESOURCE_DETAIL... ` can be used to add additional tabs to the same view
    */
-  detailTabs: {
-    /**
-     * RKE2 machine pool tabs
-     */
-    machines: boolean,
-    /**
-     * RKE2 provisioning logs
-     */
-    logs: boolean,
-    /**
-     * RKE2 registration commands
-     */
-    registration: boolean,
-    /**
-     * RKE2 snapshots
-     */
-    snapshots: boolean,
-    /**
-     * Kube resources related to the instance of provisioning.cattle.io.cluster
-     */
-    related: boolean,
-    /**
-     * Kube events associated with the instance of provisioning.cattle.io.cluster
-     */
-    events: boolean,
-    /**
-     * Kube conditions of the provisioning.cattle.io.cluster instance
-     */
-    conditions: boolean
-  };
+  detailTabs: ClusterProvisionerDetailTabs;
 
   /* --------------------------------------------------------------------------------------
    * Getters / Functions for Managing Machine Configs
@@ -225,6 +242,16 @@ export interface IClusterProvisioner {
    */
   machineConfigSchema?: { [key: string]: any };
 
+  /**
+   * Schema for infrastructure cluster object. For example infrastructure.cluster.x-k8s.io.awscluster
+   *
+   * The `id` should be in the format of `infrastructure.cluster.x-k8s.io.${ provider id }cluster`
+   *
+   * The `attributes: { kind: <value> }` should match the last part of the id
+   * The `attributes: { group: <value> }` should match the remaining parts of the id
+   */
+  infrastructureClusterSchema?: { [key: string]: any };
+
   /**
    * Override the default method to create a machine config object that will be inserted into a new machine pool
    *
@@ -257,6 +284,16 @@ export interface IClusterProvisioner {
    */
   saveMachinePoolConfigs?(pools: any[], cluster: any): Promise<any>
 
+  /**
+   * Optional custom UI section for infrastructure-cluster-specific configuration.
+   */
+  extensionInfrastructureSection?: any
+
+  /**
+   * Indicates the provisioner manages upstream CAPI infrastructure resources directly.
+   */
+  isUpstreamCAPIProvider?: boolean
+
   /* --------------------------------------------------------------------------------------
    * Optionally override parts of the cluster save process with
    * - hooks that run before or after the cluster resource is saved
@@ -276,6 +313,15 @@ export interface IClusterProvisioner {
    */
   registerSaveHooks?(registerBeforeHook: RegisterClusterSaveHook, registerAfterHook: RegisterClusterSaveHook, cluster: any): void;
 
+  /**
+   * Register hooks that run during `initSpecs` while initializing the cluster form.
+   *
+   * @param registerInitHook
+   *  Call `registerInitHook` with a function. The function will be executed during form initialization.
+   * @param cluster The cluster (`provisioning.cattle.io.cluster`)
+   */
+  registerInitHooks?(registerInitHook: RegisterClusterSaveHook, cluster: any): void;
+
   /**
    * Optionally override the save of the cluster resource itself
    *

package/core/types.ts

@@ -4,8 +4,9 @@ import type { ExtensionManager } from '@shell/types/extension-manager';
 import { PaginationSettingsStores } from '@shell/types/resources/settings';
 import type {
   ProductMetadata, ProductSinglePage,
-  StandardProductName, RouteRecordRawWithParams, ProductChildGroup,
-  ProductChildPage, ProductChild
+  StandardProductName, RouteRecordRawWithParams, ProductChild,
+  ProductChildGroup,
+  ProductChildPage
 } from './plugin-types';
 
 // Cluster Provisioning types
@@ -290,6 +291,11 @@ export interface ProductOptions {
    */
   to?: PluginRouteRecordRaw;
 
+  /**
+   * Whether the product can be removed by users (default: false — products are built-in/not removable unless explicitly set to true)
+   */
+  removable?: boolean;
+
   /**
    * Alternative to the icon property. Uses require
    */
@@ -300,6 +306,11 @@ export interface ProductOptions {
    */
   name?: string;
 
+  /**
+   *  controls whether a workspace switcher dropdown appears in the header (instead of the namespace filter) if set to true
+   */
+  showWorkspaceSwitcher?: boolean;
+
   /**
    *
    */
@@ -316,8 +327,6 @@ export interface ProductOptions {
    * Leaving these here for completeness but I don't think these should be advertised as useable to plugin creators.
    */
   // ifHaveVerb: string | RegExp;
-  // removable: string;
-  // showWorkspaceSwitcher: boolean;
   // supportRoute: string;
   // typeStoreMap: string;
 }
@@ -552,7 +561,7 @@ export interface DSLReturnType {
    * @param headers {@link HeaderOptions[]}
    * @returns {@link void}
    */
-  headers: (type: string, headers: HeaderOptions[]) => void;
+  headers: (type: string, headers?: HeaderOptions[], paginationHeaders?: PaginationHeaderOptions[]) => void;
 
   /**
    * Create and register a new product
@@ -562,12 +571,30 @@ export interface DSLReturnType {
   product: (options: ProductOptions) => void;
 
   /**
-   * Create and label a group. The group will show up in navigation
-   * @param groupNane Name of the group
-   * @param label Label in navigation
+   /**
+   * Remap group display names in the side-menu navigation.
+   *
+   * Each entry matches a group's internal ID (via string or regex) and replaces its display label
+   * with a new name. This only changes how the group is labelled in the UI — it does not move
+   * resources between groups.
+   *
+   * @param match String, string for a regex or a regex object to match against group names
+   * @param replace Replacement string or function for the display name
+   * @param weight Priority for applying this mapping (higher numbers applied first, default 5)
+   * @param continueOnMatch If true, continue matching other rules after this one matches
+   * @returns {@link void}
+   */
+  mapGroup: (match: string | RegExp, replace: string | Function, weight?: number, continueOnMatch?: boolean) => void;
+
+  /**
+   * Remap a type ID to a display name
+   * @param match String, string for a regex or a regex object to match against type IDs
+   * @param replace Replacement string or function for the display name
+   * @param weight Priority for applying this mapping (higher numbers applied first, default 5)
+   * @param continueOnMatch If true, continue matching other rules after this one matches
    * @returns {@link void}
    */
-  mapGroup: (groupName: string, label: string) => void;
+  mapType: (match: string | RegExp, replace: string | Function, weight?: number, continueOnMatch?: boolean) => void;
 
   /**
    * Create and configure a myriad of options for a type
@@ -595,18 +622,36 @@ export interface DSLReturnType {
   weightType: (input: string, weight: number, forBasic: boolean) => void;
 
   /**
-   * Leaving these here for completeness but I don't think these should be advertised as useable to plugin creators.
+   * Never show the specified type in the navigation
+   * @param regexOrString String, string for a regex or a regex object to match against type names
+   * @returns {@link void}
    */
-  // componentForType: (type: string, replacementType: string)
-  // groupBy: (type: string, field: string)
-  // hideBulkActions: (type: string, field)
-  // ignoreGroup: (regexOrString)
-  // ignoreType: (regexOrString)
-  //
-  // mapType: (match, replace)
-  // moveType: (match, group)
-  // setGroupDefaultType: (input, defaultType)
-  // spoofedType: (obj)
+  ignoreType: (regexOrString: string | RegExp) => void;
+
+  /**
+   * Never show the specified group or any types in it
+   * @param regexOrString String, string for a regex or a regex object to match against group names
+   * @param fn Conditional function that accepts getters and returns true if the group should be ignored
+   * @returns {@link void}
+   */
+  ignoreGroup: (regexOrString: string | RegExp, fn?: (getters: any) => boolean) => void;
+
+  /**
+   * Move a resource type into a different navigation group
+   * @param match String or regex to match against resource type names
+   * @param group Target group name to move the matched types into
+   * @param weight Ordering weight for the mapping (default: 5)
+   * @returns {@link void}
+   */
+  moveType: (match: string | RegExp, group: string, weight?: number) => void;
+
+  /**
+   * Control visibility of bulk actions (e.g. delete) in the list view toolbar for a specific resource type
+   * @param type The resource type to configure
+   * @param hide Whether to hide bulk actions. Set to `true` to hide them
+   * @returns {@link void}
+   */
+  hideBulkActions: (type: string, hide: boolean) => void;
 
   labelGroup: (group: string, label: string | undefined, labelKey?: string) => void;
 
@@ -657,14 +702,19 @@ export interface IExtension {
    * @internal - DO NOT USE - Internal API only
    */
   _registerTopLevelProduct(): void;
+  /**
+   *
+   * @internal - DO NOT USE - Internal API only
+   */
+  _setStartRouteWithProduct(value: boolean): void;
 
   /**
    * Add a product to the sidebar, with children and a side menu for navigation for internal pages
    * @param name
    * @param config
    */
-  addProduct(product: ProductMetadata, config: ProductChildGroup[]): void;
   addProduct(product: ProductMetadata, config: ProductChildPage[]): void;
+  addProduct(product: ProductMetadata, config: ProductChildGroup[]): void;
   addProduct(product: ProductMetadata, config: ProductChild[]): void;
 
   /**
@@ -694,8 +744,8 @@ export interface IExtension {
    * @param product Product to be extended
    * @param config Product extension configuration
    */
-  extendProduct(product: StandardProductName | string, config: ProductChildGroup[]): void;
   extendProduct(product: StandardProductName | string, config: ProductChildPage[]): void;
+  extendProduct(product: StandardProductName | string, config: ProductChildGroup[]): void;
   extendProduct(product: StandardProductName | string, config: ProductChild[]): void;
 
   /**

package/detail/__tests__/pod.test.ts

@@ -0,0 +1,41 @@
+import podDetail from '@shell/detail/pod.vue';
+
+const { containers } = podDetail.computed;
+
+describe('view: pod', () => {
+  it('should not use 2x icon sizing in init container column', () => {
+    const initContainer = { name: 'init', image: 'init:latest' };
+    const appContainer = { name: 'app', image: 'app:latest' };
+
+    const rows = containers.call({
+      allContainers: [appContainer, initContainer],
+      allStatuses:   [{
+        name:      'app',
+        ready:     true,
+        state:     {},
+        lastState: {}
+      }, {
+        name:      'init',
+        ready:     false,
+        state:     {},
+        lastState: {}
+      }],
+      dateTimeFormat: () => '',
+      t:              () => '',
+      value:          {
+        containerActions:      [],
+        containerIsInit:       (container: { name: string }) => container.name === 'init',
+        containerStateColor:   () => 'text-success',
+        containerStateDisplay: () => 'running',
+        openLogs:              jest.fn(),
+        openShell:             jest.fn(),
+      },
+    });
+
+    const initRow = rows.find((row: { name: string }) => row.name === 'init');
+    const appRow = rows.find((row: { name: string }) => row.name === 'app');
+
+    expect(initRow.initIcon).toBe('icon-checkmark text-success ml-5');
+    expect(appRow.initIcon).toBe('icon-minus text-muted ml-5');
+  });
+});

package/detail/__tests__/provisioning.cattle.io.cluster.test.ts

@@ -127,4 +127,118 @@ describe('view: provisioning.cattle.io.cluster', () => {
       expect(wrapper.vm.showRegistration).toStrictEqual(false);
     });
   });
+
+  describe('fakeMachines', () => {
+    const clusterName = 'my-cluster';
+    const poolName = 'pool1';
+    const namespace = 'fleet-default';
+    const poolFullName = `${ clusterName }-${ poolName }`;
+
+    const wrongTemplate = { metadata: { name: `${ poolFullName }-aaaa1111`, namespace } };
+    const correctTemplate = { metadata: { name: `${ poolFullName }-bbbb2222`, namespace } };
+
+    const baseValue = {
+      name:        clusterName,
+      nameDisplay: clusterName,
+      namespace,
+      machines:    [],
+      spec:        {
+        rkeConfig: {
+          machinePools: [
+            {
+              name:             poolName,
+              machineConfigRef: { name: `nc-${ poolFullName }-xyz`, kind: 'Amazonec2Config' },
+            },
+          ],
+        },
+      },
+    };
+
+    it('uses MachineDeployment infrastructureRef to select the correct template for an empty pool', async() => {
+      const machineDeployment = {
+        metadata: { name: poolFullName, namespace },
+        spec:     { template: { spec: { infrastructureRef: { name: correctTemplate.metadata.name } } } },
+      };
+
+      const wrapper = shallowMount(ProvisioningCattleIoCluster, {
+        props:  { value: baseValue },
+        global: { mocks },
+      });
+
+      await wrapper.setData({
+        allMachineDeployments: [machineDeployment],
+        machineTemplates:      [wrongTemplate, correctTemplate],
+      });
+
+      const [fakeMachine] = wrapper.vm.fakeMachines;
+
+      expect(fakeMachine.pool._template).toStrictEqual(correctTemplate);
+    });
+
+    it('returns the first prefix-matching template when no MachineDeployment exists for the pool', async() => {
+      const wrapper = shallowMount(ProvisioningCattleIoCluster, {
+        props:  { value: baseValue },
+        global: { mocks },
+      });
+
+      await wrapper.setData({
+        allMachineDeployments: [],
+        machineTemplates:      [wrongTemplate, correctTemplate],
+      });
+
+      const [fakeMachine] = wrapper.vm.fakeMachines;
+
+      expect(fakeMachine.pool._template).toStrictEqual(wrongTemplate);
+    });
+
+    it('returns undefined template when MachineDeployment infrastructureRef does not match any template', async() => {
+      const machineDeployment = {
+        metadata: { name: poolFullName, namespace },
+        spec:     { template: { spec: { infrastructureRef: { name: `${ poolFullName }-nonexistent` } } } },
+      };
+
+      const wrapper = shallowMount(ProvisioningCattleIoCluster, {
+        props:  { value: baseValue },
+        global: { mocks },
+      });
+
+      await wrapper.setData({
+        allMachineDeployments: [machineDeployment],
+        machineTemplates:      [wrongTemplate, correctTemplate],
+      });
+
+      const [fakeMachine] = wrapper.vm.fakeMachines;
+
+      expect(fakeMachine.pool._template).toBeUndefined();
+    });
+
+    it('does not include a pool in fakeMachines when it has active machines', async() => {
+      const valueWithMachines = {
+        ...baseValue,
+        machines: [
+          {
+            metadata: {
+              labels: {
+                'cluster.x-k8s.io/cluster-name':       clusterName,
+                'rke.cattle.io/rke-machine-pool-name': poolName,
+              },
+            },
+            spec: { infrastructureRef: { apiGroup: 'rke-machine.cattle.io', name: `${ poolFullName }-bbbb2222` } },
+          },
+        ],
+      };
+
+      const wrapper = shallowMount(ProvisioningCattleIoCluster, {
+        props:  { value: valueWithMachines },
+        global: { mocks },
+      });
+
+      await wrapper.setData({
+        allMachineDeployments: [],
+        machineTemplates:      [wrongTemplate, correctTemplate],
+      });
+
+      expect(wrapper.vm.fakeMachines).toHaveLength(0);
+    });
+  });
 });

package/detail/__tests__/workload.test.ts

@@ -1,156 +1,7 @@
 import Workload from '@shell/detail/workload/index.vue';
 
-const { findMatchingIngresses } = Workload.methods;
-
-describe('findMatchingIngresses', () => {
-  it('should do nothing if ingress schema is not present', () => {
-    const mockThis = {
-      ingressSchema:     undefined,
-      matchingIngresses: [],
-    };
-
-    findMatchingIngresses.call(mockThis);
-    expect(mockThis.matchingIngresses).toStrictEqual([]);
-  });
-
-  it('should not find any ingresses if there are none', () => {
-    const mockThis = {
-      ingressSchema:     true,
-      allIngresses:      [],
-      matchingIngresses: [],
-      value:             { metadata: { namespace: 'test' }, relatedServices: [] }
-    };
-
-    findMatchingIngresses.call(mockThis);
-    expect(mockThis.matchingIngresses).toStrictEqual([]);
-  });
-
-  it('should find matching ingresses', () => {
-    const mockThis = {
-      ingressSchema: true,
-      allIngresses:  [
-        { // matching
-          metadata: { namespace: 'test' },
-          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'service1' } } }] } }] }
-        }
-      ],
-      matchingIngresses: [],
-      value:             { metadata: { namespace: 'test' }, relatedServices: [{ metadata: { name: 'service1' } }] }
-    };
-
-    findMatchingIngresses.call(mockThis);
-    expect(mockThis.matchingIngresses).toHaveLength(1);
-    expect(mockThis.matchingIngresses[0]).toStrictEqual(mockThis.allIngresses[0]);
-  });
-
-  it('should not match ingresses from other namespaces', () => {
-    const mockThis = {
-      ingressSchema: true,
-      allIngresses:  [
-        { // not matching
-          metadata: { namespace: 'other' },
-          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'service1' } } }] } }] }
-        }
-      ],
-      matchingIngresses: [],
-      value:             { metadata: { namespace: 'test' }, relatedServices: [{ metadata: { name: 'service1' } }] }
-    };
-
-    findMatchingIngresses.call(mockThis);
-    expect(mockThis.matchingIngresses).toHaveLength(0);
-  });
-
-  it('should not match ingresses pointing to other services', () => {
-    const mockThis = {
-      ingressSchema: true,
-      allIngresses:  [
-        { // not matching
-          metadata: { namespace: 'test' },
-          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'service2' } } }] } }] }
-        }
-      ],
-      matchingIngresses: [],
-      value:             { metadata: { namespace: 'test' }, relatedServices: [{ metadata: { name: 'service1' } }] }
-    };
-
-    findMatchingIngresses.call(mockThis);
-    expect(mockThis.matchingIngresses).toHaveLength(0);
-  });
-
-  it('should handle ingresses with no rules', () => {
-    const mockThis = {
-      ingressSchema: true,
-      allIngresses:  [
-        {
-          metadata: { namespace: 'test' },
-          spec:     { }
-        }
-      ],
-      matchingIngresses: [],
-      value:             { metadata: { namespace: 'test' }, relatedServices: [{ metadata: { name: 'service1' } }] }
-    };
-
-    findMatchingIngresses.call(mockThis);
-    expect(mockThis.matchingIngresses).toHaveLength(0);
-  });
-
-  it('should handle ingress rules with no paths', () => {
-    const mockThis = {
-      ingressSchema: true,
-      allIngresses:  [
-        {
-          metadata: { namespace: 'test' },
-          spec:     { rules: [{ http: {} }] }
-        }
-      ],
-      matchingIngresses: [],
-      value:             { metadata: { namespace: 'test' }, relatedServices: [{ metadata: { name: 'service1' } }] }
-    };
-
-    findMatchingIngresses.call(mockThis);
-    expect(mockThis.matchingIngresses).toHaveLength(0);
-  });
-
-  it('should handle ingress paths with no backend service', () => {
-    const mockThis = {
-      ingressSchema: true,
-      allIngresses:  [
-        {
-          metadata: { namespace: 'test' },
-          spec:     { rules: [{ http: { paths: [{ backend: {} }] } }] }
-        }
-      ],
-      matchingIngresses: [],
-      value:             { metadata: { namespace: 'test' }, relatedServices: [{ metadata: { name: 'service1' } }] }
-    };
-
-    findMatchingIngresses.call(mockThis);
-    expect(mockThis.matchingIngresses).toHaveLength(0);
-  });
-
-  it('should find one of many ingresses', () => {
-    const mockThis = {
-      ingressSchema: true,
-      allIngresses:  [
-        { // not matching
-          metadata: { namespace: 'other' },
-          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'service1' } } }] } }] }
-        },
-        { // matching
-          metadata: { namespace: 'test' },
-          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'service1' } } }] } }] }
-        },
-        { // not matching
-          metadata: { namespace: 'test' },
-          spec:     { rules: [{ http: { paths: [{ backend: { service: { name: 'service2' } } }] } }] }
-        }
-      ],
-      matchingIngresses: [],
-      value:             { metadata: { namespace: 'test' }, relatedServices: [{ metadata: { name: 'service1' } }] }
-    };
-
-    findMatchingIngresses.call(mockThis);
-    expect(mockThis.matchingIngresses).toHaveLength(1);
-    expect(mockThis.matchingIngresses[0]).toStrictEqual(mockThis.allIngresses[1]);
+describe('workload detail page', () => {
+  it('should not have findMatchingIngresses method (logic moved to workload model)', () => {
+    expect(Workload.methods?.findMatchingIngresses).toBeUndefined();
   });
 });

package/detail/catalog.cattle.io.clusterrepo.vue

@@ -29,7 +29,7 @@ export default {
       class="span-3"
     >
       <h3>{{ t('tableHeaders.commit') }}</h3>
-      <span>{{ value.status.commit }}</span>
+      <span>{{ value.status?.commit }}</span>
     </div>
   </div>
 </template>

package/detail/harvesterhci.io.management.cluster.vue

@@ -5,6 +5,12 @@ import CopyCode from '@shell/components/CopyCode';
 import Tab from '@shell/components/Tabbed/Tab';
 import { allHash } from '@shell/utils/promise';
 
+// Couple of things wrong here
+// 1. It should be in pkg/harvester-manager extension
+// 2. It's not used when the harvester-ui extension is loaded
+// - extension has it's own detail/harvesterhci.io.management.cluster.vue which supersedes this
+// - unless harvester standalone uses it, it should not exist in the harvester-ui extension
+
 export default {
   emits: ['input'],
 
@@ -31,8 +37,6 @@ export default {
 
     const res = await allHash(hash);
 
-    this.allNodes = res.allNodes || [];
-    this.allNodePools = res.allNodePools || [];
     this.clusterToken = res.clusterToken;
   },
 

package/detail/pod.vue

@@ -106,7 +106,7 @@ export default {
           availableActions: this.value.containerActions,
           stateObj:         status, // Required if there's a description
           stateDescription: descriptions.join(' | '), // Required to display the description
-          initIcon:         this.value.containerIsInit(container) ? 'icon-checkmark icon-2x text-success ml-5' : 'icon-minus icon-2x text-muted ml-5',
+          initIcon:         this.value.containerIsInit(container) ? 'icon-checkmark text-success ml-5' : 'icon-minus text-muted ml-5',
 
           // Call openShell here so that opening the shell
           // at the container level still has 'this' in scope.