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

package/core/plugin-types.ts

@@ -35,6 +35,12 @@ export type ProductRegistrationRouteGenerationOptions = {
    * Generated route should omit the path property
    */
   omitPath?: boolean;
+  /**
+   * @internal
+   * Whether the route should start with the product name or not (e.g. "my-product/c/:cluster/:resource" vs "c/:cluster/my-product/:resource")
+   * only to be used in very special usecases (internal use only - check FLEET product config for an example)
+   * */
+  startRouteWithProduct?: boolean;
 }
 
 /**
@@ -72,7 +78,7 @@ export type ProductChildMetadata = {
 /**
  * Represents the allowed configuration for a custom page (virtualType)
  */
-export type VirtualTypeConfiguration = {
+export type CustomPageConfiguration = {
   /** Display only if condition is met (relates to IF_HAVE in shell/store/type-map) */
   ifHave?: boolean;
   /** Display only if feature is present (relates to shell/store/features) */
@@ -81,23 +87,44 @@ export type VirtualTypeConfiguration = {
   ifHaveType?: string;
   /** Used in conjunction with "ifHaveType", display only if resource type allows this verb (GET, POST, PUT, DELETE) */
   ifHaveVerb?: string;
-  /** Display label for the custom page */
+  /**
+   * @internal
+   * Display label for the custom page
+   */
   label?: string;
-  /** Translation key for the label */
+  /**
+   * @internal
+   * Translation key for the label
+   * */
   labelKey?: string;
-  /** Name of the page (unique identifier) */
+  /**
+   * @internal
+   * Name of the page (unique identifier)
+   */
   name?: string;
-  /** Entry route definition for this custom page */
+  /**
+   * @internal
+   * Entry route definition for this custom page
+   */
   route?: RouteRecordRawWithParams | PluginRouteRecordRaw | Object;
-  /** Icon for the custom page (relates to icons in https://github.com/rancher/icons) */
+  /**
+   * @internal
+   * Icon for the custom page (relates to icons in https://github.com/rancher/icons)
+   */
   icon?: 'compass';
   /** Whether this custom page is namespaced or not */
   namespaced?: boolean;
-  /** Ordering weight for the custom page */
+  /**
+   * @internal
+   * Ordering weight for the custom page
+   */
   weight?: number;
   /** Whether this custom page is exact match */
   exact?: boolean;
-  /** Whether this custom page will act as an overview page */
+  /**
+   * @internal
+   * Whether this custom page will act as an overview page
+   * */
   overview?: boolean;
   /** Whether this custom page has an exact path match */
   'exact-path'?: boolean;
@@ -106,7 +133,11 @@ export type VirtualTypeConfiguration = {
 /**
  * Represents the allowed configuration for a resource page (configureType)
  */
-export type ConfigureTypeConfiguration = {
+export type ResourcePageConfiguration = {
+  /**
+   * @internal
+   * Entry route definition for this custom page
+   */
   /** Override for the name displayed */
   displayName?: string;
   /** Override for the create button string on a list view */
@@ -129,25 +160,47 @@ export type ConfigureTypeConfiguration = {
   canYaml?: boolean;
   /** Show the Masthead in the edit resource component */
   resourceEditMasthead?: boolean;
-  /** Entry route definition for this resource page */
+  /**
+   * @internal
+   * Entry route definition for this resource page
+   */
   customRoute?: RouteRecordRawWithParams;
   /** Hide this type from the nav/search bar on downstream clusters (will only show in "local" cluster) */
   localOnly?: boolean;
+  /** Whether this custom page is namespaced or not */
+  namespaced?: boolean;
+  /**
+   * @internal
+   * Whether this custom page has list groups (definition for grouping items in the list view)
+   */
+  listGroups?: {
+    /** Icon for the group (relates to icons in rancher-icons */
+    icon?: string;
+    /** Value for the group (used for grouping items in the list view) */
+    value?: string;
+    /** Field for the group (used for grouping items in the list view) */
+    field?: string;
+    /** Column to hide when this group is active */
+    hideColumn?: string;
+    /** Tooltip key for the group */
+    tooltipKey?: string;
+  }[];
+  /**
+   * @internal
+   * Whether the provided list groups will override the default grouping options (e.g. group by namespace, group by cluster, etc.) or be added to them
+   */
+  listGroupsWillOverride?: boolean;
+  /**
+   * @internal
+   * Use this to configure subtypes that should be shown in the list view for this type (e.g. show "pods" and "deployments" in the list view for "workloads")
+   */
+  subTypes?: string[];
   // resource: undefined; // Use this resource in ResourceDetails instead
   // resourceDetail: undefined; // Use this resource specifically for ResourceDetail's detail component
   // resourceEdit: undefined; // Use this resource specifically for ResourceDetail's edit component
   // depaginate: undefined; // Use this to depaginate requests for this type
   // notFilterNamespace: undefined; // Define namespaces that do not need to be filtered
   // used in configureType options, to be typed later if needed
-  // listGroups: [
-  //       {
-  //         icon:       'icon-role-binding',
-  //         value:      'node',
-  //         field:      'roleDisplay',
-  //         hideColumn: ROLE.name,
-  //         tooltipKey: 'resourceTable.groupBy.role'
-  //       }
-  //     ]
 }
 
 /**
@@ -165,16 +218,6 @@ export type OverviewPageRoutingMetadata = {
   component: VueRouteComponent;
 }
 
-/**
- * Represents a custom page with a component
- */
-export type ProductChildCustomPage = ProductChildMetadata & {
-  /** Component to render for this custom page */
-  component: VueRouteComponent;
-  /** Optional configuration for the page */
-  config?: VirtualTypeConfiguration;
-};
-
 /**
  * Represents a resource page with a type (K8s resource)
  */
@@ -182,7 +225,7 @@ export type ProductChildResourcePage = {
   /** K8s resource type name for a resource page */
   type: string;
   /** Optional configuration for the resource page */
-  config?: ConfigureTypeConfiguration;
+  config?: ResourcePageConfiguration;
   /** Ordering weight for this page among its siblings */
   weight?: number;
   /** Use this to override the resource name used in the list view for this type */
@@ -197,6 +240,16 @@ export type ProductChildResourcePage = {
   sspHeaders?: PaginationHeaderOptions[];
 };
 
+/**
+ * Represents a custom page with a component
+ */
+export type ProductChildCustomPage = ProductChildMetadata & {
+  /** Component to render for this custom page */
+  component: VueRouteComponent;
+  /** Optional configuration for the page */
+  config?: CustomPageConfiguration;
+};
+
 /**
  * Represents a page item (custom page or resource page) in a product's config
  * - For custom pages: use `component` with `name` and `label`/`labelKey`

package/core/plugin.ts

@@ -124,6 +124,9 @@ export class Plugin implements IPlugin {
     this.topLevelProduct = true;
   }
 
+  _setStartRouteWithProduct(_value: boolean): void {
+  }
+
   // Track which products the plugin creates
   // Legacy DSL method
   DSL(store: any, productName: string) {

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
 };
 
 /**
@@ -238,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
    *
@@ -270,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
@@ -289,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

@@ -291,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
    */
@@ -301,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;
+
   /**
    *
    */
@@ -317,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;
 }
@@ -694,6 +702,11 @@ 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

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/provisioning.cattle.io.cluster.vue

@@ -96,7 +96,18 @@ export default {
     await this.value.waitForProvisioner();
 
     // Support for the 'provisioner' extension
-    const extClass = this.$extension.getDynamic('provisioner', this.value.machineProvider);
+    let extClass = this.$extension.getDynamic('provisioner', this.value.machineProvider);
+    let provider = this.value.machineProvider;
+
+    if (!extClass) {
+      extClass = this.$extension.getDynamic('provisioner', this.value.provisioner.toLowerCase());
+      provider = this.value.provisioner.toLowerCase();
+    }
+
+    if (!extClass && this.value.isImported) {
+      extClass = this.$extension.getDynamic('provisioner', 'imported');
+      provider = 'imported';
+    }
 
     if (extClass) {
       this.extProvider = new extClass({
@@ -111,7 +122,7 @@ export default {
         ...this.extDetailTabs,
         ...this.extProvider.detailTabs
       };
-      this.extCustomParams = { provider: this.value.machineProvider };
+      this.extCustomParams = { provider };
     }
 
     // Support for a model extension
@@ -120,7 +131,7 @@ export default {
         ...this.extDetailTabs,
         ...this.value.customProvisionerHelper.detailTabs
       };
-      this.extCustomParams = { provider: this.value.machineProvider };
+      this.extCustomParams = { provider };
     }
 
     const schema = this.$store.getters[`management/schemaFor`](CAPI.RANCHER_CLUSTER);
@@ -402,8 +413,23 @@ export default {
 
         const templateNamePrefix = `${ pool.metadata.name }-`;
 
+        // The MachineDeployment still exists for empty pools. The
+        // infrastructureRef points to the template that matches the current
+        // config. Fallback to the prefix-match to return an arbitrary template
+        // when multiple exist
+        const machineDeployment = this.allMachineDeployments.find(
+          (d) => d.metadata.name === pool.metadata.name && d.metadata.namespace === pool.metadata.namespace
+        );
+        const activeTemplateName = machineDeployment?.spec?.template?.spec?.infrastructureRef?.name;
+
         // All of these properties are needed to ensure the pool displays correctly and that we can scale up and down
-        pool._template = this.machineTemplates.find((t) => t.metadata.name.startsWith(templateNamePrefix));
+        pool._template = this.machineTemplates.find((t) => {
+          if (activeTemplateName) {
+            return t.metadata.name === activeTemplateName;
+          }
+
+          return t.metadata.name.startsWith(templateNamePrefix);
+        });
         pool._cluster = this.value;
         pool._clusterSpec = mp;