@rancher/shell 3.0.8 → 3.0.9-rc.2

package/utils/back-off.ts

@@ -1,11 +1,99 @@
-type BackOffEntry = {
-  timeoutId?: NodeJS.Timeout,
+import { randomStr } from '@shell/utils/string';
+
+type BackOffEntry<MetadataType = any> = {
   try: number,
   retries: number,
   description: string,
-  metadata: any,
+  metadata: MetadataType,
+  execute?: {
+    timeoutId?: NodeJS.Timeout,
+  },
+  recurse?: {
+    id: string,
+  }
 }
 
+interface BackOffArgs<MetadataType = any> {
+  /**
+   * Unique id for the execution of this function.
+   *
+   * This will be used to delay further executions, and also to cancel it
+   */
+  id: string,
+  /**
+   * Basic text description to use in logging
+   */
+  description: string,
+  /**
+   * Number of executions allowed before flatly refusing to call more. Defaults to 10
+   */
+  retries?: number,
+  /**
+   * Before calling delayedFn check if it can still run
+   *
+   * Useful for checking state after a looong delay
+   */
+  canFn?: () => Promise<boolean>,
+  /**
+   * Call this function
+   * - if it's not already waiting to run
+   * - if it's passed canFn
+   * - if it hasn't been tried over `retries` amount
+   *
+   * The function will be increasingly (exponentially) delayed if it has previously been called
+   */
+  delayedFn: () => Promise<any>,
+  /**
+   * Anything that might be important outside of this file (used with `getBackOff`)
+   */
+  metadata?: MetadataType,
+  /**
+   *
+   * RESET_ON_SUCCESS
+   */
+  mode?: ''
+}
+
+const metadataToString = (metadata: any) => {
+  if (!metadata) {
+    return '';
+  }
+
+  return JSON.stringify(metadata, (_, value) => {
+    return value === undefined ? '' : value;
+  });
+};
+
+export type BackOffExecuteArgs<MetadataType> = BackOffArgs<MetadataType>
+
+export interface BackOffRecurseArgs<MetadataType> extends BackOffArgs<MetadataType> {
+  /**
+   * Should we continue to to try even if the previous attempt failed?
+   */
+  continueOnError: (arg: any) => Promise<boolean>,
+}
+
+const logStyle = 'font-weight: bold; font-style: italic;';
+const logStyleReset = 'font-weight: normal; font-style: normal;';
+
+enum LOG_TYPE { // eslint-disable-line no-unused-vars
+  /** Aligns with `execute` method */
+  EXECUTE = 'delay', // eslint-disable-line no-unused-vars
+  /** Aligns with `recurse` method */
+  RECURSE = 'recurse', // eslint-disable-line no-unused-vars
+}
+type LogLevel = 'error' | 'info' | 'debug' | 'warn' | undefined;
+type LogArgs = { id: string, status: string, description: string, metadata?: any, type: string }
+
+const logInitialBackOffRequest = false;
+const calcLogLevel = (iteration: number): LogLevel => {
+  if (!logInitialBackOffRequest && iteration === 0) {
+    return undefined;
+  }
+
+  return 'info';
+};
+
 /**
  * Helper class which handles backing off making the supplied request
  *
@@ -16,21 +104,65 @@ class BackOff {
    [id: string]: BackOffEntry
   } = {};
 
-  private log(level: 'error' | 'info' | 'debug', id: string, classDescription: string, description: string, ...args: any[]) {
-    console[level](`BackOff... Id: "${ id }". Description: "${ description }"\nStatus: ${ classDescription }\n`, ...args); // eslint-disable-line no-console
+  private getLogTypeFromMap(id: string): string {
+    const entry = this.getBackOff(id);
+
+    let safeType = '';
+
+    if (!!entry?.execute) {
+      safeType = LOG_TYPE.EXECUTE;
+    } else if (!!entry?.recurse) {
+      safeType = LOG_TYPE.RECURSE;
+    }
+
+    return safeType;
+  }
+
+  private log(level: LogLevel, {
+    id, status, description, metadata, type
+  }: LogArgs, ...args: any[]) {
+    if (!level) {
+      return;
+    }
+
+    let safeType = type || this.getLogTypeFromMap(id);
+
+    safeType = safeType ? ` (${ safeType })` : '';
+
+    // eslint-disable-next-line no-console
+    console[level](
+      `%cBackOff${ safeType }%c... \n%cId%c:          ${ id }\n%cDescription%c: ${ description }\n%cStatus%c:      ${ status }\n%cMetadata%c:    ${ metadataToString(metadata) }\n%cCache %c:       ${ Object.keys(this.map).map((e) => `"${ e }"`).join(' + ') }`,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      logStyle, logStyleReset,
+      ...args
+    );
+  }
+
+  private logAndError(level: LogLevel, {
+    id, status, description, metadata, type
+  }: LogArgs, ...args: any[]): Promise<undefined> {
+    this.log(level, {
+      id, status, description, metadata, type
+    }, ...args);
+
+    return Promise.reject(new Error(status));
   }
 
   /**
    * Get a specific back off process
    */
-  getBackOff(id: string): BackOffEntry {
+  public getBackOff(id: string): BackOffEntry {
     return this.map[id];
   }
 
   /**
    * Stop ALL back off processes started since the ui was loaded
    */
-  resetAll() {
+  public resetAll() {
     Object.keys(this.map).forEach((id) => {
       this.reset(id);
     });
@@ -39,7 +171,7 @@ class BackOff {
   /**
    * Stop all back off process with a specific prefix
    */
-  resetPrefix(prefix:string) {
+  public resetPrefix(prefix:string) {
     Object.keys(this.map).forEach((id) => {
       if (id.startsWith(prefix)) {
         this.reset(id);
@@ -50,23 +182,148 @@ class BackOff {
   /**
    * Stop a back off process with a specific id
    */
-  reset(id: string) {
+  public reset(id: string) {
     const backOff: BackOffEntry = this.map[id];
 
-    if (backOff) {
-      if (backOff?.timeoutId) {
-        this.log('info', id, 'Stopping (cancelling active back-off)', backOff.description);
+    if (!backOff) {
+      return;
+    }
+
+    const logType = this.getLogTypeFromMap(id);
+
+    if (backOff?.execute?.timeoutId) {
+      this.log('info', {
+        id, status: 'Stopping (cancelling active back-off)', description: backOff.description, metadata: backOff.metadata, type: logType
+      });
+
+      clearTimeout(backOff.execute.timeoutId);
+    }
+    const backOffTry = backOff?.try || 0;
+    const logLevel = backOffTry <= 1 ? undefined : 'debug';
 
-        clearTimeout(backOff.timeoutId);
+    delete this.map[id];
+
+    this.log(logLevel, {
+      id, status: 'Reset', description: backOff.description, metadata: backOff.metadata, type: logType
+    });
+  }
+
+  private sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  private calcDelay = (iteration: number) => {
+    // First step is immediate (0.001s)
+    // Second and others are exponential
+    // Iteration: 1,     2,   3,     4,    5,      6,    7,       8,    9
+    // Delay:     0.25s, 1s,  2.25s, 4s,   6.25s,  9s,   12.25s,  16s,  20.25s
+    return iteration === 0 ? 1 : Math.pow(iteration, 2) * 250;
+  }
+
+  private canRecurse = async(backOffEntry: BackOffEntry, {
+    id, description, metadata, canFn = async() => true
+  }: BackOffRecurseArgs<any>) => {
+    if (!this.map[id]) {
+      // was reset, don't care now, abort
+      // could be a pagination-wrapper request with a stale revision, which can be safely ignored
+      return this.logAndError('info', {
+        id, status: 'Aborting (backoff was reset, do not continue to process)', description, metadata, type: LOG_TYPE.RECURSE
+      });
+    }
+
+    if (this.map[id].recurse?.id !== backOffEntry.recurse?.id) {
+      return this.logAndError('info', {
+        id, status: 'Aborting (stale backoff, a new one exists)', description, metadata, type: LOG_TYPE.RECURSE
+      });
+    }
+
+    const cont = await canFn();
+
+    if (!cont) {
+      return this.logAndError('info', {
+        id, status: 'Skipping (canFn test failed)', description, metadata, type: LOG_TYPE.RECURSE
+      });
+    }
+  };
+
+  /**
+   * Call a function, if it fails keep trying but with a delay (aka back off)
+   *
+   * Return the successful result, or error if reached the max number of retries
+   *
+   * @template MetadataType - Type of configuration that can be internally stored with the backoff record
+   */
+  public async recurse<MetadataType = any, ResponseType = any>(args: BackOffRecurseArgs<MetadataType>): Promise<ResponseType | undefined> {
+    const {
+      id, description, retries = 10, delayedFn, continueOnError, metadata
+    } = args;
+
+    if (this.map[id]) {
+      return this.logAndError('info', {
+        id, status: 'Skipping (previous recurse back off process still running)', description, metadata, type: 'recurse',
+      });
+    }
+
+    this.map[id] = {
+      try:     1,
+      retries,
+      description,
+      metadata,
+      recurse: { id: randomStr() }
+    };
+
+    for (let i = 0; i < retries; i++) {
+      await this.canRecurse(this.map[id], args); // Check that we can start the process
+
+      this.map[id].try = i + 1;
+
+      const delay = this.calcDelay(i);
+      const logLevel = calcLogLevel(i);
+
+      this.log(logLevel, {
+        id, status: `Delaying call (attempt ${ i + 1 }, delayed by ${ delay }ms)`, description, metadata, type: LOG_TYPE.RECURSE
+      });
+
+      await this.sleep(delay);
+
+      await this.canRecurse(this.map[id], args); // Check that we can call the function (things could have changed after delay...)
+
+      this.log(logLevel, {
+        id, status: `Executing call`, description, metadata, type: LOG_TYPE.RECURSE
+      });
+
+      let res: ResponseType | undefined;
+
+      try {
+        res = await delayedFn();
+      } catch (e) {
+        const cont = await continueOnError(e);
+
+        if (!cont) {
+          this.reset(id); // Allow future calls to execute
+
+          const errorMessage = 'Failed call';
+
+          return this.logAndError('error', {
+            id, status: errorMessage, description, metadata, type: LOG_TYPE.RECURSE
+          }, e);
+        }
       }
-      this.log('debug', id, 'Reset', backOff.description);
 
-      delete this.map[id];
+      if (res) {
+        await this.canRecurse(this.map[id], args); // Check that we can return a result (things could have changed after delayedFn...)
+
+        this.reset(id); // Allow future calls to execute
+
+        this.log(logLevel, {
+          id, status: 'Successful call', description, metadata, type: LOG_TYPE.RECURSE
+        });
+
+        return res;
+      }
     }
   }
 
   /**
-   * Call a function, but if it's recently been called delay execution aka back off
+   * Call a function, but if it's recently been called delay execution (aka back off)
    *
    * This can be used in a totally disjoined asynchronous way
    *
@@ -76,91 +333,67 @@ class BackOff {
    * 4. Repeat steps 2 and 3, with an exponential increasing delay
    *
    * This can be called repeatedly, if the previous delay is still running new requests will be ignored
+   *
+   * @template MetadataType - Type of configuration that can be internally stored with the backoff record
    */
-  async execute<T = any>({
+  public async execute<MetadataType = any>({
     id, description, retries = 10, delayedFn, canFn = async() => true, metadata
-  }: {
-    /**
-     * Unique id for the execution of this function.
-     *
-     * This will be used to delay further executions, and also to cancel it
-     */
-    id: string,
-    /**
-     * Basic text description to use in logging
-     */
-    description: string,
-    /**
-     * Number of executions allowed before flatly refusing to call more. Defaults to 10
-     */
-    retries?: number,
-    /**
-     * Before calling delayedFn check if it can still run
-     *
-     * Useful for checking state after a looong delay
-     */
-    canFn?: () => Promise<boolean>,
-    /**
-     * Call this function
-     * - if it's not already waiting to run
-     * - if it's passed canFn
-     * - if it hasn't been tried over `retries` amount
-     *
-     * The function will be increasingly (exponentially) delayed if it has previously been called
-     */
-    delayedFn: () => Promise<any>,
-    /**
-     * Anything that might be important outside of this file (used with `getBackOff`)
-     */
-    metadata?: T,
-  }): Promise<NodeJS.Timeout | undefined> {
+  }: BackOffExecuteArgs<MetadataType>): Promise<NodeJS.Timeout | undefined> {
     const backOff: BackOffEntry = this.map[id];
 
     const cont = await canFn();
 
     if (!cont) {
-      this.log('info', id, 'Skipping (can execute fn test failed)', description);
+      this.log('info', {
+        id, status: 'Skipping (canExecute test failed)', description, metadata, type: LOG_TYPE.EXECUTE
+      });
 
       return undefined;
-    } else if (backOff?.timeoutId) {
-      this.log('info', id, 'Skipping (previous back off process still running)', description);
+    } else if (backOff?.execute?.timeoutId) {
+      this.log('info', {
+        id, status: 'Skipping (previous back off process still running)', description, metadata, type: LOG_TYPE.EXECUTE
+      });
 
-      return backOff.timeoutId;
+      return backOff?.execute?.timeoutId;
     } else {
       const backOffTry = backOff?.try || 0;
 
       if (backOffTry + 1 > retries) {
-        this.log('error', id, 'Aborting (too many retries)', description);
+        this.log('error', {
+          id, status: 'Aborting (too many retries)', description, metadata, type: LOG_TYPE.EXECUTE
+        });
 
         return undefined;
       }
 
-      // First step is immediate (0.001s)
-      // Second and others are exponential
-      // Try:         1,     2,   3,     4,    5,      6,    7,       8,    9
-      // Multiple:    1,     4,   9,     16,   25,     36,   49,      64,   81
-      // Actual Time: 0.25s, 1s,  2.25s, 4s,   6.25s,  9s,   12.25s,  16s,  20.25s
-      const delay = backOffTry === 0 ? 1 : Math.pow(backOffTry, 2) * 250;
+      const delay = this.calcDelay(backOffTry);
+      const logLevel = calcLogLevel(backOffTry);
 
-      this.log('info', id, `Delaying call (attempt ${ backOffTry + 1 }, delayed by ${ delay }ms)`, description);
+      this.log(logLevel, {
+        id, status: `Delaying call (attempt ${ backOffTry + 1 }, delayed by ${ delay }ms)`, description, metadata, type: LOG_TYPE.EXECUTE
+      });
 
       const timeout = setTimeout(async() => {
         try {
-          this.log('info', id, `Executing call`, description);
+          this.log(logLevel, {
+            id, status: `Executing call`, description, metadata, type: LOG_TYPE.EXECUTE
+          });
 
           await delayedFn();
         } catch (e) {
           // Error occurred. Don't clear the map. Next time this is called we'll back off before trying ...
-          this.log('error', id, 'Failed call', description, e);
+          this.log('error', {
+            id, status: 'Failed call', description, metadata, type: LOG_TYPE.EXECUTE
+          });
         }
 
         // Unblock future calls
-        delete this.map[id]?.timeoutId;
+        delete this.map[id]?.execute?.timeoutId;
       }, delay);
 
       this.map[id] = {
-        timeoutId: timeout,
-        try:       backOff?.try ? backOff.try + 1 : 1,
+        execute: { timeoutId: timeout },
+        try:     backOff?.try ? backOff.try + 1 : 1,
         retries,
         description,
         metadata

package/utils/cspAdaptor.ts

@@ -1,12 +1,13 @@
 // For testing these could be changed to something like...
 
 import { CATALOG } from '@shell/config/types';
+import { ActionFindPageArgs, ActionFindPageTransientResponse } from '@shell/types/store/dashboard-store.types';
 import { FilterArgs, PaginationFilterField, PaginationParamFilter } from '@shell/types/store/pagination.types';
 import { VuexStore } from '@shell/types/store/vuex';
 
 const CSP_ADAPTER_APPS = ['rancher-csp-adapter', 'rancher-csp-billing-adapter'];
 // For testing above line could be replaced with below line...
-// const cspAdaptorApp = ['rancher-webhooka', 'rancher-webhook'];
+// const CSP_ADAPTER_APPS = ['rancher-webhooka', 'rancher-webhook'];
 
 /**
  * Helpers in order to
@@ -16,27 +17,44 @@ class CspAdapterUtils {
     return $store.getters[`management/paginationEnabled`]({ id: CATALOG.APP, context: 'branding' });
   }
 
-  static fetchCspAdaptorApp($store: VuexStore): Promise<any> {
+  private static apps?: any[] = undefined;
+  public static resetState() {
+    this.apps = undefined;
+  }
+
+  static async fetchCspAdaptorApp($store: VuexStore): Promise<any> {
+    if (this.apps) {
+      return this.apps;
+    }
+
     // For the login page, the schemas won't be loaded - we don't need the apps in this case
     if ($store.getters['management/canList'](CATALOG.APP)) {
       if (CspAdapterUtils.canPagination($store)) {
         // Restrict the amount of apps we need to fetch
-        return $store.dispatch('management/findPage', {
+        const opt: ActionFindPageArgs = {
+          pagination: new FilterArgs({
+            filters: PaginationParamFilter.createMultipleFields(CSP_ADAPTER_APPS.map(
+              (t) => new PaginationFilterField({
+                field: 'metadata.name',
+                value: t,
+              })
+            )),
+          }),
+          watch:     false,
+          transient: true
+        };
+
+        const resp: ActionFindPageTransientResponse = await $store.dispatch('management/findPage', {
           type: CATALOG.APP,
-          opt:  { // Of type ActionFindPageArgs
-            pagination: new FilterArgs({
-              filters: PaginationParamFilter.createMultipleFields(CSP_ADAPTER_APPS.map(
-                (t) => new PaginationFilterField({
-                  field: 'metadata.name',
-                  value: t,
-                })
-              )),
-            })
-          }
+          opt
         });
+
+        this.apps = resp.data;
+      } else {
+        this.apps = await $store.dispatch('management/findAll', { type: CATALOG.APP });
       }
 
-      return $store.dispatch('management/findAll', { type: CATALOG.APP });
+      return this.apps;
     }
 
     return Promise.resolve([]);

package/utils/dynamic-content/__tests__/index.test.ts

@@ -244,7 +244,7 @@ describe('dynamic content', () => {
         logger:   mockLogger,
         config:   mockConfig,
         isAdmin:  true,
-        settings: { releaseNotesUrl: '', suseExtensions: [] },
+        settings: { suseExtensions: [] },
       };
     });
 

package/utils/dynamic-content/__tests__/new-release.test.ts

@@ -7,6 +7,7 @@ import semver from 'semver';
 
 describe('processReleaseVersion', () => {
   let mockContext: Context;
+  let mockContextPrime: Context;
   let mockDispatch: jest.Mock;
   let mockGetters: any;
   let mockLogger: any;
@@ -50,10 +51,24 @@ describe('processReleaseVersion', () => {
         prime:        false,
         distribution: 'community',
       },
-      settings: {
-        releaseNotesUrl: 'https://example.com/releases/v$version',
-        suseExtensions:  [],
+      settings: { suseExtensions: [] },
+    };
+
+    mockContextPrime = {
+      dispatch: mockDispatch,
+      getters:  mockGetters,
+      axios:    {},
+      logger:   mockLogger,
+      isAdmin:  true,
+      config:   {
+        enabled:      true,
+        debug:        false,
+        log:          false,
+        endpoint:     '',
+        prime:        true,
+        distribution: 'prime',
       },
+      settings: { suseExtensions: [] },
     };
 
     // Mock the utility function. Default: notification does not exist, so add it.
@@ -119,7 +134,7 @@ describe('processReleaseVersion', () => {
       },
       primaryAction: {
         label:  'More Info',
-        target: 'https://example.com/releases/v2.12.1',
+        target: 'https://github.com/rancher/rancher/releases/tag/v2.12.1',
       },
     });
     expect(mockRemoveMatchingNotifications).toHaveBeenCalledWith(mockContext, 'new-release-', '2.12.1');
@@ -145,12 +160,38 @@ describe('processReleaseVersion', () => {
       },
       primaryAction: {
         label:  'More Info',
-        target: 'https://example.com/releases/v2.13.0',
+        target: 'https://github.com/rancher/rancher/releases/tag/v2.13.0',
       },
     });
     expect(mockRemoveMatchingNotifications).toHaveBeenCalledWith(mockContext, 'new-release-', '2.13.0');
   });
 
+  it('should add a single new release notification for a newer major/minor version (no patch) (Prime)', async() => {
+    const releaseInfo = [{ name: '2.13.0' }, { name: '2.12.0' }];
+    const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: true };
+
+    await processReleaseVersion(mockContextPrime, releaseInfo, versionInfo);
+
+    expect(mockLogger.info).toHaveBeenCalledWith('Found a newer release: 2.13.0');
+    expect(mockLogger.info).not.toHaveBeenCalledWith(expect.stringContaining('Also found a newer patch release'));
+    expect(mockDispatch).toHaveBeenCalledTimes(1);
+    expect(mockDispatch).toHaveBeenCalledWith('notifications/add', {
+      id:         'new-release-2.13.0',
+      level:      NotificationLevel.Announcement,
+      title:      'A new Rancher release is available',
+      message:    'Rancher 2.13.0 has been released',
+      preference: {
+        key:   READ_NEW_RELEASE,
+        value: '2.13.0',
+      },
+      primaryAction: {
+        label:  'More Info',
+        target: 'https://documentation.suse.com/cloudnative/rancher-manager/v2.13/en/release-notes/v2.13.0.html',
+      },
+    });
+    expect(mockRemoveMatchingNotifications).toHaveBeenCalledWith(mockContextPrime, 'new-release-', '2.13.0');
+  });
+
   it('should add a multiple new releases notification when both newer patch and newer major/minor exist', async() => {
     const releaseInfo = [{ name: '2.13.0' }, { name: '2.12.1' }, { name: '2.12.0' }];
     const versionInfo: VersionInfo = { version: semver.coerce('2.12.0')!, isPrime: false };
@@ -171,11 +212,11 @@ describe('processReleaseVersion', () => {
       },
       primaryAction: {
         label:  'More Info for 2.12.1',
-        target: 'https://example.com/releases/v2.12.1',
+        target: 'https://github.com/rancher/rancher/releases/tag/v2.12.1',
       },
       secondaryAction: {
         label:  'More Info for 2.13.0',
-        target: 'https://example.com/releases/v2.13.0',
+        target: 'https://github.com/rancher/rancher/releases/tag/v2.13.0',
       },
     });
     expect(mockRemoveMatchingNotifications).toHaveBeenCalledWith(mockContext, 'new-release-', '2.12.1-2.13.0');

package/utils/dynamic-content/__tests__/support-notice.test.ts

@@ -52,10 +52,7 @@ describe('processSupportNotices', () => {
         prime:        false,
         distribution: 'community',
       },
-      settings: {
-        releaseNotesUrl: '',
-        suseExtensions:  [],
-      },
+      settings: { suseExtensions: [] },
     };
 
     // Mock the utility function. Default: notification does not exist, so add it.

package/utils/dynamic-content/index.ts

@@ -30,8 +30,6 @@ const LOCAL_STORAGE_UPDATE_FETCHING = 'rancher-updates-fetching'; // Local stora
 
 const BACKOFFS = [1, 1, 1, 2, 2, 3, 5]; // Backoff in days for the contiguous number of errors (i.e. after 1 errors, we wait 1 day, after 3 errors, we wait 2 days, etc.)
 
-const DEFAULT_RELEASE_NOTES_URL = 'https://github.com/rancher/rancher/releases/tag/v$version'; // Default release notes URL
-
 /**
  * Fetch dynamic content if needed and process it if it has changed since we last checked
  */
@@ -63,10 +61,7 @@ export async function fetchAndProcessDynamicContent(dispatch: Function, getters:
     logger,
     config,
     isAdmin:  isAdminUser(getters),
-    settings: {
-      releaseNotesUrl: DEFAULT_RELEASE_NOTES_URL,
-      suseExtensions:  [],
-    }
+    settings: { suseExtensions: [] }
   };
 
   logger.debug('Read configuration', context.config);