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

package/store/aws.js

@@ -12,9 +12,10 @@ export const state = () => {
 };
 
 class Handler {
-  constructor(cloudCredentialId, options) {
+  constructor(cloudCredentialId, options, proxyApi) {
     this.cloudCredentialId = (cloudCredentialId || '');
     this.fetchHandler = new FetchHttpHandler(options);
+    this.proxyApi = proxyApi;
   }
 
   async handle(httpRequest, options = {}) {
@@ -24,24 +25,34 @@ class Handler {
 
     httpRequest.headers['x-api-headers-restrict'] = 'Content-Length';
 
-    if (this.cloudCredentialId) {
-      httpRequest.headers['x-api-cattleauth-header'] = `awsv4 credID=${ this.cloudCredentialId }`;
-    } else if (httpRequest?.headers['authorization']) {
-      httpRequest.headers['x-api-auth-header'] = httpRequest.headers['authorization'];
-    }
+    // Build proxy options: use awsv4 credential signing when a cloud credential
+    // is available, otherwise forward the SDK-generated Authorization header
+    // directly via x-api-auth-header.
+    const upstreamUrl = new URL(`https://${ httpRequest.hostname }${ httpRequest.path }`);
+    const proxyOptions = this.cloudCredentialId ? {
+      url:            upstreamUrl,
+      authentication: {
+        id:         this.cloudCredentialId,
+        authSigner: 'awsv4',
+      },
+    } : {
+      url:     upstreamUrl,
+      headers: httpRequest?.headers['authorization'] ? { 'x-api-auth-header': httpRequest.headers['authorization'] } : {},
+    };
+
+    const { url: proxyPath, headers: proxyHeaders } = this.proxyApi.prepareRequest(proxyOptions);
 
+    // Merge proxy auth headers; remove the upstream Authorization and the
+    // Accept header added by prepareRequest (AWS SDK manages its own Accept).
+    Object.assign(httpRequest.headers, proxyHeaders);
     delete httpRequest.headers['authorization'];
+    delete httpRequest.headers['Accept'];
 
     const originalContentType = httpRequest.headers['content-type'] ?? '';
 
     httpRequest.headers['content-type'] = originalContentType ? `rancher:${ originalContentType }` : 'rancher:';
 
-    const endpoint = `/meta/proxy/`;
-
-    if (!httpRequest.path.startsWith(endpoint)) {
-      httpRequest.path = endpoint + httpRequest.hostname + httpRequest.path;
-    }
-
+    httpRequest.path = proxyPath;
     httpRequest.protocol = window.location.protocol;
     httpRequest.hostname = window.location.hostname;
     httpRequest.port = window.location.port;
@@ -114,7 +125,7 @@ export const actions = {
     const client = new lib.EC2({
       region,
       credentialDefaultProvider: credentialDefaultProvider(accessKey, secretKey),
-      requestHandler:            new Handler(cloudCredentialId),
+      requestHandler:            new Handler(cloudCredentialId, undefined, this.$shell.proxy),
       useDualstackEndpoint:      true,
     });
 
@@ -129,7 +140,7 @@ export const actions = {
     const client = new lib.EKS({
       region,
       credentialDefaultProvider: credentialDefaultProvider(accessKey, secretKey),
-      requestHandler:            new Handler(cloudCredentialId),
+      requestHandler:            new Handler(cloudCredentialId, undefined, this.$shell.proxy),
       useDualstackEndpoint:      true,
     });
 
@@ -144,7 +155,7 @@ export const actions = {
     const client = new lib.KMS({
       region,
       credentialDefaultProvider: credentialDefaultProvider(accessKey, secretKey),
-      requestHandler:            new Handler(cloudCredentialId),
+      requestHandler:            new Handler(cloudCredentialId, undefined, this.$shell.proxy),
       useDualstackEndpoint:      true,
     });
 
@@ -159,7 +170,7 @@ export const actions = {
     const client = new lib.IAM({
       region,
       credentialDefaultProvider: credentialDefaultProvider(accessKey, secretKey),
-      requestHandler:            new Handler(cloudCredentialId),
+      requestHandler:            new Handler(cloudCredentialId, undefined, this.$shell.proxy),
       useDualstackEndpoint:      true,
     });
 

package/store/catalog.js

@@ -302,6 +302,16 @@ export const mutations = {
     state.namespacedRepos = namespaced;
   },
 
+  addClusterRepo(state, repo) {
+    if (!state.clusterRepos) {
+      state.clusterRepos = [];
+    }
+
+    if (!state.clusterRepos.find((r) => r.metadata?.name === repo.metadata?.name)) {
+      state.clusterRepos.push(repo);
+    }
+  },
+
   setCharts(state, { charts, errors = [], loaded = [] }) {
     state.charts = charts;
     state.errors = errors;
@@ -445,6 +455,53 @@ export const actions = {
     }
   },
 
+  async loadRepo(ctx, { repoName }) {
+    const {
+      state, getters, rootGetters, commit, dispatch
+    } = ctx;
+
+    const inStore = rootGetters['currentCluster'] ? rootGetters['currentProduct'].inStore : 'management';
+
+    let repo = rootGetters[`${ inStore }/byId`](CATALOG.CLUSTER_REPO, repoName);
+
+    if (!repo) {
+      try {
+        repo = await dispatch(`${ inStore }/find`, { type: CATALOG.CLUSTER_REPO, id: repoName }, { root: true });
+      } catch (e) {
+        return;
+      }
+    }
+
+    if (!repo) {
+      return;
+    }
+
+    commit('addClusterRepo', repo);
+
+    if (getters.isLoaded(repo)) {
+      return;
+    }
+
+    try {
+      const index = await repo.followLink('index');
+      const charts = { ...state.charts };
+
+      for (const k in index?.entries) {
+        for (const entry of index.entries[k]) {
+          addChart(ctx, charts, entry, repo);
+        }
+      }
+
+      commit('setCharts', {
+        charts,
+        errors: state.errors,
+        loaded: [repo],
+      });
+    } catch (e) {
+      console.error(`Failed to load repo ${ repoName }:`, e); // eslint-disable-line no-console
+    }
+  },
+
   /**
    * Globally refreshes all loaded repositories by triggering their refresh actions concurrently,
    * bypassing individual catalog loads, and then performs a single, global catalog/load.
@@ -559,7 +616,10 @@ function addChart(ctx, map, chart, repo) {
 
     const primeOnly = chart.annotations?.[CATALOG_ANNOTATIONS.PRIME_ONLY] === 'true';
     const experimental = !!chart.annotations?.[CATALOG_ANNOTATIONS.EXPERIMENTAL];
-    const windowsIncompatible = !(chart.annotations?.[CATALOG_ANNOTATIONS.PERMITTED_OS] || '').includes('windows');
+
+    const isRancherRepoFlag = isRancherRepo(repo, chart);
+    const permittedSystems = getPermittedOSs(chart.annotations, isRancherRepoFlag);
+    const windowsIncompatible = permittedSystems.length > 0 && !permittedSystems.includes('windows');
     const deploysOnWindows = (chart.annotations?.[CATALOG_ANNOTATIONS.DEPLOYED_OS] || '').includes('windows');
     const tags = [];
 
@@ -608,6 +668,7 @@ function addChart(ctx, map, chart, repo) {
       provides:         [],
       windowsIncompatible,
       deploysOnWindows,
+      isRancherRepo:    isRancherRepoFlag,
       tags
     });
 
@@ -692,13 +753,13 @@ export function compatibleVersionsFor(chart, os, includePrerelease = true) {
   }
 
   return versions.filter((ver) => {
-    const osPermitted = (ver?.annotations?.[CATALOG_ANNOTATIONS.PERMITTED_OS] || LINUX).split(',');
+    const osPermitted = getPermittedOSs(ver?.annotations, chart?.isRancherRepo);
 
     if ( !includePrerelease && isPrerelease(ver.version) ) {
       return false;
     }
 
-    if ( !os || difference(os, osPermitted).length === 0) {
+    if ( !os || osPermitted.length === 0 || difference(os, osPermitted).length === 0) {
       return true;
     }
 
@@ -787,3 +848,23 @@ export function filterAndArrangeCharts(charts, {
 
   return sortBy(out, ['certifiedSort', 'repoName', 'chartNameDisplay']);
 }
+
+/**
+ * Detects if a repository is a Rancher repository.
+ */
+export function isRancherRepo(repo, chart) {
+  return !!(chart?.isRancherRepo || repo?.isRancherSource);
+}
+
+/**
+ * Returns an array of permitted operating systems for a given chart or version.
+ * If the chart explicitly defines permitted OSs via annotation, those are returned.
+ * Otherwise, if the chart is from a Rancher repository, it defaults to Linux.
+ * External charts with no annotations have no OS restrictions (returns empty array).
+ */
+export function getPermittedOSs(annotations, isRancher) {
+  const permittedOs = annotations?.[CATALOG_ANNOTATIONS.PERMITTED_OS];
+  const fallbackOs = isRancher ? LINUX : '';
+
+  return (permittedOs || fallbackOs).split(',').filter(Boolean);
+}

package/store/digitalocean.js

@@ -1,5 +1,5 @@
 import { sortBy } from '@shell/utils/sort';
-import { addParam, addParams } from '@shell/utils/url';
+import { createDepaginator } from '@shell/apis/shell/proxy';
 
 const ENDPOINT = 'api.digitalocean.com/v2';
 
@@ -149,50 +149,32 @@ export const actions = {
     return out;
   },
 
-  async request({ dispatch }, {
-    token, credentialId, command, opt, out
+  async request(_, {
+    token, credentialId, command, opt
   }) {
     opt = opt || {};
 
-    let url = '/meta/proxy/';
+    const url = new URL(opt.url || `https://${ ENDPOINT }/${ command }`);
 
-    if ( opt.url ) {
-      url += opt.url.replace(/^https?:\/\//, '');
-    } else {
-      url += `${ ENDPOINT }/${ command }`;
-      url = addParam(url, 'per_page', opt.per_page || 1000);
-      url = addParams(url, opt.params || {});
-    }
-
-    const headers = { Accept: 'application/json' };
-
-    if ( credentialId ) {
-      headers['x-api-cattleauth-header'] = `Bearer credID=${ credentialId } passwordField=accessToken`;
-    } else if ( token ) {
-      headers['x-api-auth-header'] = `Bearer ${ token }`;
-    }
-
-    const res = await dispatch('management/request', {
-      url,
-      headers,
-      redirectUnauthorized: false,
-    }, { root: true });
-
-    if ( out ) {
-      out[command] = out[command].concat(res[command]);
-    } else {
-      out = res;
+    url.searchParams.set('per_page', `${ opt.per_page || 1000 }`);
+    if (opt.params) {
+      for (const [key, value] of Object.entries(opt.params)) {
+        url.searchParams.set(key, value);
+      }
     }
 
-    // De-pagination
-    if ( res?.links?.pages?.next ) {
-      opt.url = res.links.pages.next;
+    const authentication = credentialId ? {
+      id:            credentialId,
+      authSigner:    'bearer',
+      passwordField: 'accessToken',
+    } : { token };
 
-      return dispatch('request', {
-        token, credentialId, command, opt, out
-      });
-    }
+    const proxy = this.$shell?.proxy;
+    const requestOptions = { url, authentication };
 
-    return out;
+    return proxy.request({
+      ...requestOptions,
+      postProcess: createDepaginator(proxy, requestOptions, { mergeKey: command }),
+    });
   },
 };

package/store/index.js

@@ -1041,6 +1041,8 @@ export const actions = {
     // This is a workaround for a timing issue where the mgmt cluster schema may not be available
     // Try and wait until the schema exists before proceeding
     await dispatch('management/waitForSchema', { type: MANAGEMENT.CLUSTER });
+    // Similarly to above, we somehow get here without everything in management land being ready. FF needed to determine pagination state
+    await dispatch('management/waitForHaveAll', { type: MANAGEMENT.FEATURE });
 
     // If SSP is on we won't have requested all clusters
     if (!paginateClusters({ rootGetters, state })) {

package/store/linode.js

@@ -1,5 +1,5 @@
 import { sortBy } from '@shell/utils/sort';
-import { addParam, addParams } from '@shell/utils/url';
+import { createDepaginator } from '@shell/apis/shell/proxy';
 
 const ENDPOINT = 'api.linode.com/v4';
 
@@ -93,50 +93,35 @@ export const actions = {
     return out;
   },
 
-  async request({ dispatch }, {
-    token, credentialId, command, opt, out
+  async request(_, {
+    token, credentialId, command, opt
   }) {
     opt = opt || {};
 
-    let url = '/meta/proxy/';
+    const url = new URL(opt.url || `https://${ ENDPOINT }/${ command }`);
 
-    if ( opt.url ) {
-      url += opt.url.replace(/^https?:\/\//, '');
-    } else {
-      url += `${ ENDPOINT }/${ command }`;
-      url = addParam(url, 'per_page', opt.per_page || 1000);
-      url = addParams(url, opt.params || {});
+    url.searchParams.set('per_page', `${ opt.per_page || 1000 }`);
+    if (opt.params) {
+      for (const [key, value] of Object.entries(opt.params)) {
+        url.searchParams.set(key, value);
+      }
     }
 
-    const headers = { Accept: 'application/json' };
-
-    if ( credentialId ) {
-      headers['X-API-CattleAuth-Header'] = `Bearer credID=${ credentialId } passwordField=token`;
-    } else if ( token ) {
-      headers['X-API-Auth-Header'] = `Bearer ${ token }`;
-    }
-
-    const res = await dispatch('management/request', {
-      url,
-      headers,
-      redirectUnauthorized: false,
-    }, { root: true });
-
-    if ( out ) {
-      out[command] = out[command].concat(res[command]);
-    } else {
-      out = res;
-    }
-
-    // De-pagination
-    if ( res?.links?.pages?.next ) {
-      opt.url = res.links.pages.next;
-
-      return dispatch('request', {
-        token, credentialId, command, opt, out
-      });
-    }
-
-    return out;
+    const authentication = credentialId ? {
+      id:            credentialId,
+      authSigner:    'bearer',
+      passwordField: 'token',
+    } : { token };
+
+    const proxy = this.$shell.proxy;
+    const requestOptions = { url, authentication };
+
+    return proxy.request({
+      ...requestOptions,
+      postProcess: createDepaginator(proxy, requestOptions, {
+        nextUrlPath: 'links.pages.next',
+        mergeKey:    command,
+      }),
+    });
   }
 };

package/store/plugins.js

@@ -172,14 +172,14 @@ export const getters = {
     return async(name) => {
       const schema = getters.schemaForDriver(name);
 
-      await schema.fetchResourceFields();
-
       if ( !schema ) {
         // eslint-disable-next-line no-console
         console.error(`Machine Driver Config schema not found for ${ name }`);
 
         return [];
       }
+      await schema.fetchResourceFields();
+
       // This is used in places where `createPopulated` has been called, which has called fetchResourceFields to populate resourceFields
       const out = Object.keys(schema?.resourceFields || {});
 
@@ -191,13 +191,16 @@ export const getters = {
 
   fieldsForDriver(state, getters) {
     return async(name) => {
+      const out = {};
       const schema = getters.schemaForDriver(name);
 
+      if ( !schema ) {
+        return out;
+      }
+
       await schema.fetchResourceFields();
       const names = await getters.fieldNamesForDriver(name);
 
-      const out = {};
-
       for ( const n of names ) {
         out[n] = schema.resourceFields[n];
       }

package/store/pnap.js

@@ -68,6 +68,7 @@ export const actions = {
     return out;
   },
 
+  // DEPRECATED: accessing /meta/proxy directly is deprecated
   async request({ dispatch }, {
     clientId, clientSecret, credentialId, command, opt, out
   }) {

package/store/type-map.js

@@ -20,7 +20,7 @@
 // importList(type)                 Returns a promise that resolves to the list component for type
 // importDetail(type[,subType])     Returns a promise that resolves to the detail component for type
 // importEdit(type[,subType])       Returns a promise that resolves to the edit component for type
-// optionsFor(schemaOrType)         Return the configured options for a type (from configureType)
+// optionsFor(schemaOrType, pagination(bool), product(string)) Return the configured options for a type (from configureType) - additional product param can be passed if "optionsFor" needed isn't the current product
 //
 // 3) Changing specialization info about a type
 // For all:
@@ -107,6 +107,7 @@
 //                               notFilterNamespace:  undefined -- Define namespaces that do not need to be filtered
 //                               localOnly: False -- Hide this type from the nav/search bar on downstream clusters
 //                               custom: any - Custom options for a given type
+//                               product: string - If set, this type's options will only apply when that product is active
 //                           }
 // )
 // ignoreGroup(group):        Never show group or any types in it
@@ -269,20 +270,25 @@ export function DSL(store, product, module = 'type-map') {
       store.commit(`${ module }/groupBy`, { type, field });
     },
 
-    headers(type, headers, paginationHeaders = []) {
-      headers.forEach((header) => {
+    headers(type, headers = [], paginationHeaders = []) {
+      if (headers.length) {
+        headers.forEach((header) => {
         // If on the client, then use the value getter if there is one
-        if (header.getValue) {
+          if (header.getValue) {
           // we need to store the .value prop for the advanced filtering
-          header.valueProp = header.value;
-          header.value = header.getValue;
-        }
+            header.valueProp = header.value;
+            header.value = header.getValue;
+          }
 
-        delete header.getValue;
-      });
+          delete header.getValue;
+        });
 
-      store.commit(`${ module }/headers`, { type, headers });
-      store.commit(`${ module }/paginationHeaders`, { type, paginationHeaders });
+        store.commit(`${ module }/headers`, { type, headers });
+      }
+
+      if (paginationHeaders.length) {
+        store.commit(`${ module }/paginationHeaders`, { type, paginationHeaders });
+      }
     },
 
     hideBulkActions(type, field) {
@@ -290,7 +296,9 @@ export function DSL(store, product, module = 'type-map') {
     },
 
     configureType(match, options) {
-      store.commit(`${ module }/configureType`, { ...options, match });
+      store.commit(`${ module }/configureType`, {
+        ...options, match, product
+      });
     },
 
     componentForType(match, replace) {
@@ -371,6 +379,18 @@ export function DSL(store, product, module = 'type-map') {
   };
 }
 
+const LEGACY_COMPATIBILITY_BUCKET = 'legacyCompatibilityProdRegistration';
+
+function validateProductName(product) {
+  if (!product || typeof product !== 'string' || product.trim() === '') {
+    throw new Error(`Product name must be a non-empty string, got: ${ JSON.stringify(product) }`);
+  }
+
+  if (product === LEGACY_COMPATIBILITY_BUCKET) {
+    throw new Error(`Product name cannot be "${ LEGACY_COMPATIBILITY_BUCKET }" as it is reserved for backward compatibility`);
+  }
+}
+
 let called = false;
 
 export async function applyProducts(store, $extension) {
@@ -412,7 +432,7 @@ export const state = function() {
     typeMappings:            [],
     typeMoveMappings:        [],
     typeToComponentMappings: [],
-    typeOptions:             [],
+    typeOptions:             {},
     groupBy:                 {},
     headers:                 {},
     paginationHeaders:       {},
@@ -549,15 +569,37 @@ export const getters = {
       subTypes:                 [],
     };
 
-    return (schemaOrType, pagination) => {
+    return (schemaOrType, pagination, product) => {
       // Note - This can run a LOT so needs to be performant
 
       if (!schemaOrType) {
         return {};
       }
 
+      if (product) {
+        validateProductName(product);
+      }
+
       const type = (typeof schemaOrType === 'object' ? schemaOrType.id : schemaOrType);
-      const found = state.typeOptions.find((entry) => {
+      const productToUse = product || rootGetters['productId'];
+
+      // Handle both array (pre-2.15) and object (2.15+) state.typeOptions formats for backwards compatibility
+      let productTypeOptions = [];
+
+      if (Array.isArray(state.typeOptions)) {
+        // Legacy format: filter the flat array for entries matching the product or entries without a product field
+        productTypeOptions = state.typeOptions.filter((entry) => entry.product === productToUse || !entry.product
+        );
+      } else {
+        // New format: direct object lookup by product, with fallback to legacy compatibility bucket for unscoped entries
+        // (e.g., extensions compiled with pre-2.15 shell that don't send product parameter)
+        productTypeOptions = [
+          ...(state.typeOptions[productToUse] || []),
+          ...(state.typeOptions[LEGACY_COMPATIBILITY_BUCKET] || [])
+        ];
+      }
+
+      const found = productTypeOptions.find((entry) => {
         const re = stringToRegex(entry.match);
 
         return re.test(type);
@@ -944,7 +986,7 @@ export const getters = {
         });
 
         const attrs = schema.attributes || {};
-        const typeOptions = getters['optionsFor'](schema);
+        const typeOptions = getters['optionsFor'](schema, undefined, product);
 
         schemaModes[TYPE_MODES.BASIC] = schemaModes[TYPE_MODES.BASIC] && getters.groupForBasicType(product, schema.id);
 
@@ -1522,6 +1564,10 @@ export const mutations = {
       delete state.virtualTypes[product];
     }
 
+    if (state.typeOptions[product]) {
+      delete state.typeOptions[product];
+    }
+
     if (state.basicTypes[product]) {
       // Remove table header configuration
       Object.keys(state.basicTypes[product]).forEach((type) => {
@@ -1784,20 +1830,54 @@ export const mutations = {
   },
 
   configureType(state, options) {
-    const match = regexToString(ensureRegex(options.match));
+    const { product, ...typeOptions } = options;
+    const match = regexToString(ensureRegex(typeOptions.match));
+
+    // Handle both old (array) and new (object) state.typeOptions formats for backwards compatibility
+    // Old format (pre-2.15): state.typeOptions = []
+    // New format (2.15+): state.typeOptions = { productName: [...] }
+    if (Array.isArray(state.typeOptions)) {
+      // Legacy path: old format for extensions compiled with pre-2.15 shell
+      // In 2.14, product parameter is not validated/enforced
+      const idx = state.typeOptions.findIndex((obj) => obj.match === match);
+      let obj = { ...options, match };
+
+      if ( idx >= 0 ) {
+        // Merge the custom data object - multiple configures will update existing rather than overwrite
+        obj.custom = Object.assign(state.typeOptions[idx].custom || {}, obj.custom || {});
+        obj = Object.assign(state.typeOptions[idx], obj);
+        state.typeOptions.splice(idx, 1, obj);
+      } else {
+        state.typeOptions.push(obj);
+      }
+    } else {
+      // New path: object format with product scoping (2.15+)
+      // Product is required in new format
+      if (!product) {
+        throw new Error(`configureType: product parameter is required in Rancher 2.15+, not provided for type "${ match }"`);
+      }
 
-    const idx = state.typeOptions.findIndex((obj) => obj.match === match);
-    let obj = { ...options, match };
+      validateProductName(product);
 
-    if ( idx >= 0 ) {
-      // Merge the custom data object - multiple configures will update existing rather than overwrite
-      obj.custom = Object.assign(state.typeOptions[idx].custom || {}, obj.custom || {});
-      obj = Object.assign(state.typeOptions[idx], obj);
-      state.typeOptions.splice(idx, 1, obj);
-    } else {
-      const obj = Object.assign({}, options, { match });
+      // Initialize product's typeOptions array if needed
+      if (!state.typeOptions[product]) {
+        state.typeOptions[product] = [];
+      }
+
+      const productTypeOptions = state.typeOptions[product];
+      const idx = productTypeOptions.findIndex((obj) => obj.match === match);
+      let obj = { ...typeOptions, match };
 
-      state.typeOptions.push(obj);
+      if ( idx >= 0 ) {
+        // Merge the custom data object - multiple configures will update existing rather than overwrite
+        obj.custom = Object.assign(productTypeOptions[idx].custom || {}, obj.custom || {});
+        obj = Object.assign(productTypeOptions[idx], obj);
+        productTypeOptions.splice(idx, 1, obj);
+      } else {
+        const obj = Object.assign({}, typeOptions, { match });
+
+        productTypeOptions.push(obj);
+      }
     }
   },
 
@@ -1836,8 +1916,10 @@ export const actions = {
     dispatch('prefs/set', { key: EXPANDED_GROUPS, value: groups }, { root: true });
   },
 
-  configureType({ commit }, options) {
-    commit('configureType', options);
+  configureType({ commit, rootGetters }, options) {
+    const product = options.product || rootGetters['productId'];
+
+    commit('configureType', { ...options, product });
   }
 };