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

package/utils/grafana.js

@@ -1,6 +1,5 @@
-import { haveV2Monitoring } from '@shell/utils/monitoring';
+import { haveV2Monitoring, fetchMonitoringVersion } from '@shell/utils/monitoring';
 import { parse as parseUrl, addParam } from '@shell/utils/url';
-import { CATALOG } from '@shell/config/types';
 
 // these two versions of monitoring included a bug fix attempt that required the local cluster to use a different url
 // the solution going forward doesn't require this, see https://github.com/rancher/dashboard/issues/8885
@@ -60,21 +59,7 @@ export async function dashboardExists(monitoringVersion, store, clusterId, embed
 }
 
 export async function allDashboardsExist(store, clusterId, embeddedUrls, storeName = 'cluster', projectId = null) {
-  let res;
-
-  let monitoringVersion = '';
-
-  if (!projectId && store.getters[`${ storeName }/canList`](CATALOG.APP)) {
-    try {
-      res = await store.dispatch(`${ storeName }/find`, {
-        type: CATALOG.APP,
-        id:   'cattle-monitoring-system/rancher-monitoring'
-      });
-    } catch (err) {
-    }
-
-    monitoringVersion = res?.currentVersion;
-  }
+  const monitoringVersion = projectId ? '' : await fetchMonitoringVersion(store, storeName);
 
   const existPromises = embeddedUrls.map((url) => dashboardExists(monitoringVersion, store, clusterId, url, storeName, projectId));
 

package/utils/monitoring.js

@@ -1,6 +1,6 @@
 // Helpers for determining if V2 or v1 Monitoring are installed
 
-import { SCHEMA, MONITORING, ENDPOINTS } from '@shell/config/types';
+import { SCHEMA, MONITORING, ENDPOINTS, CATALOG } from '@shell/config/types';
 import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
 import { findBy } from '@shell/utils/array';
 import { isEmpty } from '@shell/utils/object';
@@ -30,6 +30,43 @@ export function haveV2Monitoring(getters) {
 
 export const CATTLE_MONITORING_NAMESPACE = 'cattle-monitoring-system';
 
+/**
+ * Look up the installed Rancher monitoring app, preferring the new
+ * `rancher-monitoring-dashboards` chart and falling back to the legacy
+ * `rancher-monitoring`. Returns null if the user lacks permission, neither
+ * chart is installed, or any lookup fails.
+ */
+export async function fetchMonitoringApp(store, storeName) {
+  if (!store.getters[`${ storeName }/canList`](CATALOG.APP)) {
+    return null;
+  }
+
+  const ids = [
+    `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-dashboards`,
+    `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring`,
+  ];
+
+  for (const id of ids) {
+    try {
+      const res = await store.dispatch(`${ storeName }/find`, { type: CATALOG.APP, id });
+
+      if (res) {
+        return res;
+      }
+    } catch (err) {
+      // Try the next id; both failing means nothing is installed.
+    }
+  }
+
+  return null;
+}
+
+export async function fetchMonitoringVersion(store, storeName) {
+  const app = await fetchMonitoringApp(store, storeName);
+
+  return app?.currentVersion || '';
+}
+
 async function hasEndpointSubsets(store, id) {
   if (store.getters['cluster/schemaFor'](ENDPOINTS)) {
     const endpoints = await store.dispatch('cluster/findAll', { type: ENDPOINTS }) || [];

package/utils/operation-cr.js

@@ -0,0 +1,19 @@
+/**
+ * Create a day 2 operation CR for imported clusters.
+ *
+ * @param {Function} dispatch - The Vuex dispatch function
+ * @param {string} type - The operation CRD type
+ * @param {object} spec - The operation spec
+ * @param {string} namespace - The namespace for the operation CR
+ * @param {string} namePrefix - The name prefix for the generated name
+ * @returns {Promise} The saved resource
+ */
+export async function createOperationCR(dispatch, type, spec, namespace, namePrefix) {
+  const resource = await dispatch('management/create', {
+    type,
+    metadata: { namespace, generateName: `${ namePrefix }-` },
+    spec,
+  }, { root: true });
+
+  return resource.save();
+}

package/utils/require-asset.ts

@@ -88,6 +88,13 @@ export function requireJson(path: string): object {
   return mod.default || mod;
 }
 
+// Expose asset resolvers on window so extension builds (which use a stub
+// instead of require.context) can delegate to the host dashboard at runtime.
+if (typeof window !== 'undefined') {
+  (window as any).__shell_requireAsset = requireAsset;
+  (window as any).__shell_requireJson = requireJson;
+}
+
 // Exported for testing — allows injecting mock contexts
 export function _setContexts(img: WebpackRequireContext | null, json: WebpackRequireContext | null): void {
   imgCtx = img;

package/utils/validators/__tests__/private-registry.test.ts

@@ -3,28 +3,22 @@ import { privateRegistryRequired } from '@shell/utils/validators/private-registr
 const makeCtx = (overrides: any = {}) => ({
   t:                      jest.fn((key: string, params?: any) => (params ? `${ key }:${ JSON.stringify(params) }` : key)),
   privateRegistryEnabled: false,
-  normanCluster:          { importedConfig: { privateRegistryURL: null } },
-  isImportedCluster:      true,
+  normanCluster:          { importedConfig: {} },
+  $store:                 { getters: { 'management/byId': () => null } },
   ...overrides,
 });
 
-describe('privateRegistryRequired', () => {
-  it('should return undefined when the cluster is not imported', () => {
-    const ctx = makeCtx({ isImportedCluster: false, privateRegistryEnabled: true });
-    const rule = privateRegistryRequired(ctx);
-
-    expect(rule()).toBeUndefined();
-  });
+const storeWithGlobalRegistry = { getters: { 'management/byId': () => ({ value: 'registry.global.io' }) } };
 
-  it('should default isImportedCluster to true when the property is absent from the context', () => {
-    const ctx: any = {
-      t:                      jest.fn((key: string, params?: any) => (params ? `${ key }:${ JSON.stringify(params) }` : key)),
+describe('privateRegistryRequired', () => {
+  it('should return undefined when a global default registry is configured', () => {
+    const ctx = makeCtx({
       privateRegistryEnabled: true,
-      normanCluster:          { importedConfig: { privateRegistryURL: null } },
-    };
+      $store:                 storeWithGlobalRegistry,
+    });
     const rule = privateRegistryRequired(ctx);
 
-    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+    expect(rule()).toBeUndefined();
   });
 
   it('should return undefined when the registry toggle is off', () => {
@@ -73,4 +67,22 @@ describe('privateRegistryRequired', () => {
 
     expect(rule()).toBeUndefined();
   });
+
+  it('should handle $store getter throwing gracefully', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: {} },
+      $store:                 {
+        getters: {
+          get 'management/byId'() {
+            throw new Error('no store');
+          }
+        }
+      },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    // Falls through to validation since no global default detected
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
 });

package/utils/validators/private-registry.ts

@@ -1,19 +1,30 @@
+import { VuexStore } from 'types/store/vuex';
 import { Translation } from '@shell/types/t';
 import formRulesGenerator from '@shell/utils/validators/formRules';
+import { SETTING } from '@shell/config/settings';
+import { MANAGEMENT } from '@shell/config/types';
 
 interface PrivateRegistryRuleContext {
   t: Translation;
   privateRegistryEnabled: boolean;
   normanCluster: { importedConfig?: { privateRegistryURL?: string | null } } | null;
-  isImportedCluster?: boolean;
+  $store: VuexStore
 }
 
 export function privateRegistryRequired(ctx: PrivateRegistryRuleContext) {
   return () => {
-    // Check existence using `in` rather than direct access to avoid Vue's render-time warning
-    const isImported = 'isImportedCluster' in ctx ? !!ctx.isImportedCluster : true;
+    let hasGlobalDefault = false;
 
-    if (!isImported || !ctx.privateRegistryEnabled) {
+    try {
+      // settings are loaded when the dashboard loads so using a synchronous getter is reliable here
+      const globalRegistrySetting = ctx.$store.getters['management/byId'](MANAGEMENT.SETTING, SETTING.SYSTEM_DEFAULT_REGISTRY);
+
+      hasGlobalDefault = !!globalRegistrySetting?.value;
+    } catch {
+      // if no setting proceed like there's no global default
+    }
+
+    if (!ctx.privateRegistryEnabled || hasGlobalDefault) {
       return undefined;
     }
     const url = ctx.normanCluster?.importedConfig?.privateRegistryURL;