@rancher/shell 3.0.11 → 3.0.12-rc.1

package/types/store/dashboard-store.types.ts

@@ -83,6 +83,11 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
 
   saveCountAs?: string,
 
+  /**
+   * When making a supporting HTTP request include associated resource data
+   */
+  includeAssociatedData?: boolean,
+
   /**
    * The target minimum revision for the resource.
    *

package/types/store/pagination.types.ts

@@ -607,6 +607,7 @@ export interface StorePaginationRequest {
    * The single namespace to filter results by (as part of url path, not pagination params)
    */
   namespace?: string,
+
   /**
    * The set of pagination args used to create the request
    */
@@ -616,6 +617,11 @@ export interface StorePaginationRequest {
    * Does this request stem from a list with manual refresh?
    */
   hasManualRefresh?: boolean,
+
+  /**
+   * When making a supporting HTTP request include associated resource data
+   */
+  includeAssociatedData?: boolean,
 }
 
 /**

package/utils/axios.js

@@ -1,5 +1,5 @@
 import Axios from 'axios';
-import defu from 'defu';
+
 import axiosRetry from 'axios-retry';
 
 // Axios.prototype cannot be modified
@@ -37,9 +37,6 @@ const axiosExtra = {
   onError(fn) {
     this.onRequestError(fn);
     this.onResponseError(fn);
-  },
-  create(options) {
-    return createAxiosInstance(defu(options, this.defaults));
   }
 };
 

package/utils/dynamic-importer.js

@@ -94,8 +94,9 @@ export function loadProduct(name) {
 }
 
 export function listProducts() {
-  const ctx = require.context('@shell/config/product', true, /.*/);
-  const products = ctx.keys().filter(path => !path.endsWith('.js') && path.startsWith('./')).map(path => path.substr(2));
+  // We just want the .js or .ts files
+  const ctx = require.context('@shell/config/product', true, /\.\/.*\.[js|ts]/);
+  const products = ctx.keys().map(path => path.substr(2)).map(path => path.slice(0, -3));
 
   return products;
 }

package/utils/pagination-utils.ts

@@ -299,7 +299,7 @@ class PaginationUtils {
     return isEqual(aPrimitiveTypes, bPrimitiveTypes) &&
       this.paginationFiltersEqual(aFilter, bFilter) &&
       this.paginationFiltersEqual(aPN, bPN) &&
-      sameArrayObjects<PaginationSort>(aSort, bSort, true);
+      sameArrayObjects<PaginationSort>(aSort, bSort, false);
   }
 }
 

package/utils/uiplugins.ts

@@ -5,14 +5,15 @@ import { UI_PLUGIN_BASE_URL, isSupportedChartVersion, UI_PLUGIN_LABELS } from '@
 import { Plugin, Version } from '@shell/types/uiplugins';
 
 const MAX_RETRIES = 10;
-const RETRY_WAIT = 2500;
+const RETRY_WAIT = 2500; // 2.5 seconds
+const ACTIVE_STATUS_TIMEOUT = 200000; // 20 seconds
 
 type Action = 'install' | 'upgrade';
 export type HelmRepository = any;
 export type HelmChart = any;
 
 /**
- *
+ * Get the latest compatible version of a Helm Chart extension
  * @param store Vue store
  * @param chartName The chartName
  * @param rancherVersion Rancher version
@@ -68,8 +69,8 @@ export async function waitForUIExtension(store: any, name: string, maxRetries =
         return extension;
       }
     } catch (e) {
+      console.error('waiting for UI extension to be available: error =', e); // eslint-disable-line no-console
     }
-
     tries++;
 
     if (tries > maxRetries) {
@@ -106,7 +107,6 @@ export async function waitForUIPackage(store: any, extension: any, maxRetries =
       return true;
     } catch (error) {
     }
-
     tries++;
 
     if (tries > maxRetries) {
@@ -199,7 +199,7 @@ export async function getHelmRepositoryMatch(store: any, urlRegexes: string[], c
 }
 
 /**
- *
+ * Get a Helm Repository matching the given criteria.
  * @param store Vue store
  * @param matchFn Match function for repository's urls
  * @returns HelmRepository
@@ -225,15 +225,15 @@ export async function refreshHelmRepository(store: any, url: string): Promise<vo
   const now = (new Date()).toISOString().replace(/\.\d+Z$/, 'Z');
 
   repository.spec.forceUpdate = now;
-
   await repository.save();
 
-  await repository.waitForState('active', 10000, 1000);
+  await repository.waitForState('active', ACTIVE_STATUS_TIMEOUT, RETRY_WAIT);
 
   await new Promise((resolve) => setTimeout(resolve, 2000));
 }
 
 /**
+ * Create a Helm Repository and wait for it to be downloaded
  *
  * @param store Vue store
  * @param name Repository name
@@ -260,7 +260,7 @@ export async function createHelmRepository(store: any, name: string, url: string
 
   const helmRepo = await repo.save();
 
-  // Poll the repository until it says it has been downloaded
+  // Poll the repository status MAX_RETRIES times until it has been downloaded
   let fetched = false;
   let tries = 0;
 
@@ -275,23 +275,19 @@ export async function createHelmRepository(store: any, name: string, url: string
 
     const downloaded = repo.status.conditions.find((s: any) => s.type === 'Downloaded');
 
-    if (downloaded) {
-      if (downloaded.status === 'True') {
-        fetched = true;
-      }
+    console.log(`Waiting for helm repository to be downloaded... try ${ tries } time(s).`); // eslint-disable-line no-console
+
+    if (downloaded && downloaded.status === 'True') {
+      fetched = true;
     }
 
     if (!fetched) {
-      tries++;
-
       if (tries > MAX_RETRIES) {
         throw new Error('Failed to add Helm Chart Repository');
       }
 
       await new Promise((resolve) => setTimeout(resolve, RETRY_WAIT));
     }
-
-    fetched = true;
   }
 
   // Return the Helm Repository

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

@@ -0,0 +1,76 @@
+import { privateRegistryRequired } from '@shell/utils/validators/private-registry';
+
+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,
+  ...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();
+  });
+
+  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)),
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: null } },
+    };
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
+
+  it('should return undefined when the registry toggle is off', () => {
+    const ctx = makeCtx({ privateRegistryEnabled: false });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toBeUndefined();
+  });
+
+  it('should return a required error when enabled but the url is empty', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: '' } },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
+
+  it('should return a required error when normanCluster.importedConfig is missing', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          {},
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
+
+  it('should return a format error when enabled and the url is malformed', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: 'goober' } },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('cluster.privateRegistry.privateRegistryUrlError');
+  });
+
+  it('should return undefined when enabled and the url is valid', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: 'registry.io:5000' } },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toBeUndefined();
+  });
+});

package/utils/validators/private-registry.ts

@@ -0,0 +1,28 @@
+import { Translation } from '@shell/types/t';
+import formRulesGenerator from '@shell/utils/validators/formRules';
+
+interface PrivateRegistryRuleContext {
+  t: Translation;
+  privateRegistryEnabled: boolean;
+  normanCluster: { importedConfig?: { privateRegistryURL?: string | null } } | null;
+  isImportedCluster?: boolean;
+}
+
+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;
+
+    if (!isImported || !ctx.privateRegistryEnabled) {
+      return undefined;
+    }
+    const url = ctx.normanCluster?.importedConfig?.privateRegistryURL;
+
+    if (!url) {
+      return ctx.t('validation.required', { key: ctx.t('cluster.privateRegistry.label') });
+    }
+    const { registryUrl } = formRulesGenerator(ctx.t, { key: ctx.t('cluster.privateRegistry.label') });
+
+    return (registryUrl as (val: string) => string | undefined)(url);
+  };
+}