@rancher/shell 3.0.7 → 3.0.8-rc.1

package/utils/dynamic-content/util.ts

@@ -0,0 +1,122 @@
+/**
+ *
+ * The code in this file provides utility functions for dynamic content
+ *
+ * First up is a helper to remove notifications that match a given prefix
+ * Second up is a basic logging helper than will log to the console but can also log to local storage
+ * so that we have a persistent log of what the dynamic content code has been doing to help with debugging
+ *
+ */
+
+import { randomStr } from '@shell/utils/string';
+import { Configuration, Context } from './types';
+import { Notification } from '@shell/types/notifications';
+
+const MAX_LOG_MESSAGES = 50;
+
+export const LOCAL_STORAGE_CONTENT_DEBUG_LOG = 'rancher-updates-debug-log';
+
+/**
+ * Remove all notifications that have the given prefix, except the one that has the specified current id
+ *
+ * Returns whether a notification with the current id was found
+ *
+ * @param dispatch Store dispatcher
+ * @param getters Store getters
+ * @param prefix Prefix to look for and remove notifications whose IDs start with this prefix
+ * @param currentId  Current ID of notification to keep, if present
+ * @returns If a notification with the current ID was found
+ */
+export async function removeMatchingNotifications(context: Context, prefix: string, currentId: string): Promise<boolean> {
+  const { dispatch, getters, logger } = context;
+  const id = `${ prefix }${ currentId }`;
+  let found = false;
+  let removed = 0;
+  const all = getters['notifications/all'] || [];
+  const ids = all.map((n: Notification) => n.id);
+
+  for (let i = 0; i < ids.length; i++) {
+    const notificationId = ids[i];
+
+    if (notificationId.startsWith(prefix)) {
+      if (notificationId === id) {
+        found = true;
+      } else {
+        await dispatch('notifications/remove', notificationId);
+        removed++;
+
+        logger.debug(`Remove matching notifications ${ prefix }, ${ currentId } - removed notification ${ notificationId }`);
+      }
+    }
+  }
+
+  if (found) {
+    logger.debug(`Remove matching notifications ${ prefix }, ${ currentId } - found an existing notification (removed ${ removed })`);
+  } else {
+    logger.debug(`Remove matching notifications ${ prefix }, ${ currentId } - did not find an existing notification (removed ${ removed })`);
+  }
+
+  return found;
+}
+
+/**
+ * Create a logger interface that can be used to log messages and errors appropriately
+ * @param config Configuration to help us determine where and when to log
+ * @returns Logger interface with methods to log for error, info and debug
+ */
+export function createLogger(config: Configuration) {
+  return {
+    error: (message: string, ...args: any[]) => log(config, 'error', message, ...args),
+    info:  (message: string, ...args: any[]) => log(config, 'info', message, ...args),
+    debug: (message: string, ...args: any[]) => log(config, 'debug', message, ...args),
+  };
+}
+
+/**
+ * Actual logging function that logs appropriately
+ * @param config Configuration to help us determine where and when to log
+ * @param level Log level (error, info, debug)
+ * @param message Log message
+ * @param arg Optional argument to be logged
+ */
+function log(config: Configuration, level: string, message: string, ...args: any[]) {
+  // Log to the console when appropriate
+  if (level === 'error') {
+    console.error(message, ...args); // eslint-disable-line no-console
+  } else if (level === 'info' && config.log) {
+    console.info(message, ...args); // eslint-disable-line no-console
+  } else if (level === 'debug' && config.debug) {
+    console.debug(message, ...args); // eslint-disable-line no-console
+  }
+
+  // Only log to local storage if the configuration says we should
+  if (config.log) {
+    // Add the log message to the log we keep in local storage
+    try {
+      let data = [];
+
+      // If we can't parse the data in local storage, then we will reset to an emptry array
+      try {
+        data = JSON.parse(window.localStorage.getItem(LOCAL_STORAGE_CONTENT_DEBUG_LOG) || '[]');
+      } catch {}
+
+      const item = {
+        level,
+        message,
+        timestamp: new Date().toISOString(),
+        args,
+        uuid:      randomStr(),
+      };
+
+      data.unshift(item);
+
+      // Limit the number of log messages
+      window.localStorage.setItem(LOCAL_STORAGE_CONTENT_DEBUG_LOG, JSON.stringify(data.slice(0, MAX_LOG_MESSAGES)));
+
+      // Send an event so the UI can update if necessary
+      const event = new CustomEvent('dynamicContentLog', { detail: item });
+
+      window.dispatchEvent(event);
+    } catch {}
+  }
+}

package/utils/inactivity.ts

@@ -0,0 +1,104 @@
+import { EXT } from '@shell/config/types';
+import { RancherKubeMetadata } from '@shell/types/kube/kube-api';
+
+interface UserActivityResponse {
+  metadata: RancherKubeMetadata,
+  status: {
+    expiresAt: string
+  }
+}
+
+interface ParsedInactivitySetting {
+  expiresAt: string | undefined,
+  sessionTokenName: string | undefined,
+  courtesyTimer: number | undefined,
+  courtesyCountdown: number | undefined,
+  showModalAfter: number | undefined
+}
+
+interface SpecData {
+  tokenId: string;
+  seenAt?: string;
+}
+
+export class Inactivity {
+  private sessionTokenName: string | undefined = undefined;
+
+  public getSessionTokenName(): string | undefined {
+    return this.sessionTokenName;
+  }
+
+  public setSessionTokenName(tokenName: string): void {
+    this.sessionTokenName = tokenName;
+  }
+
+  public async getUserActivity(store: any, sessionTokenName: string, force = true): Promise<UserActivityResponse> {
+    try {
+      const updatedData = await store.dispatch('management/find', {
+        type: EXT.USER_ACTIVITY,
+        id:   sessionTokenName,
+        opt:  {
+          force, watch: false, logoutOnError: false
+        }
+      });
+
+      return updatedData;
+    } catch (e: any) {
+      if (e._status === 401) {
+        return store.dispatch('auth/logout', { sessionIdle: true });
+      }
+
+      console.error(`Could not GET UserActivity for session token ${ sessionTokenName }`, e); // eslint-disable-line no-console
+      throw new Error(e);
+    }
+  }
+
+  public async updateUserActivity(userActivityResource: any, sessionTokenName: string, seenAt: string): Promise<UserActivityResponse> {
+    const spec: SpecData = { tokenId: sessionTokenName };
+
+    if (seenAt) {
+      spec.seenAt = seenAt;
+    }
+
+    userActivityResource.spec = spec;
+
+    try {
+      const savedData = await userActivityResource.save({ force: true });
+
+      return savedData;
+    } catch (e: any) {
+      console.error(`Could not update (POST) UserActivity for session token ${ sessionTokenName }`, e); // eslint-disable-line no-console
+      throw new Error(e);
+    }
+  }
+
+  public parseTTLData(userActivityData: UserActivityResponse): ParsedInactivitySetting {
+    const currDate = Date.now();
+    const endDate = new Date(userActivityData.status?.expiresAt).getTime();
+
+    // let's give this a 3 second buffer so that we can make sure the logout happens by the frontend
+    const thresholdSeconds = Math.floor((endDate - currDate) / 1000) - 3;
+
+    // Amount of time the user sees the inactivity warning
+    const courtesyTimerVal = Math.floor(thresholdSeconds * 0.2); // the modal is shown for 10% of the total time to display
+    const courtesyTimer = Math.min(courtesyTimerVal, 60 * 5); // Never show the modal more than 5 minutes
+
+    const courtesyCountdown = courtesyTimer;
+
+    // Amount of time before the user sees the inactivity warning
+    // Note - time before warning is shown + time warning is shown = settings threshold (total amount of time)
+    const showModalAfter = thresholdSeconds - courtesyTimer;
+
+    return {
+      expiresAt:        userActivityData.status?.expiresAt,
+      sessionTokenName: userActivityData.metadata?.name,
+      courtesyTimer,
+      courtesyCountdown,
+      showModalAfter
+    };
+  }
+}
+
+const instance = new Inactivity();
+
+export default instance;

package/utils/pagination-utils.ts

@@ -1,4 +1,6 @@
-import { PaginationFeature, PaginationSettings, PaginationSettingsStore, PaginationSettingsStores } from '@shell/types/resources/settings';
+import {
+  PaginationFeature, PaginationFeatureHomePageClusterConfig, PaginationFeatureName, PaginationSettings, PaginationSettingsFeatures, PaginationSettingsStore, PaginationSettingsStores
+} from '@shell/types/resources/settings';
 import {
   NAMESPACE_FILTER_ALL_USER as ALL_USER,
   NAMESPACE_FILTER_ALL as ALL,
@@ -22,6 +24,15 @@ import { EXT_IDS } from '@shell/core/plugin';
 import { ExtensionManager } from '@shell/types/extension-manager';
 import { DEFAULT_PERF_SETTING } from '@shell/config/settings';
 
+const homePageClusterFeature: PaginationFeature<PaginationFeatureHomePageClusterConfig> = {
+  version:       1,
+  enabled:       true,
+  configuration: {
+    threshold: 500, results: 250, pagesPerRow: 25
+  }
+};
+const PAGINATION_SETTINGS_FEATURE_DEFAULTS: PaginationSettingsFeatures = { homePageCluster: homePageClusterFeature };
+
 /**
  * Helper functions for server side pagination
  */
@@ -222,15 +233,19 @@ class PaginationUtils {
     return this.isFeatureEnabled({ rootGetters }, 'listManualRefresh');
   }
 
-  private isFeatureEnabled({ rootGetters }: any, featureName: PaginationFeature): boolean {
+  getFeature<Config = any>({ rootGetters }: any, featureName: PaginationFeatureName): PaginationFeature<Config> | undefined {
     // Cache must be enabled to support pagination api
     if (!this.isSteveCacheEnabled({ rootGetters })) {
-      return false;
+      return undefined;
     }
 
     const settings = this.getSettings({ rootGetters });
 
-    return !!settings.features?.[featureName]?.enabled;
+    return settings.features?.[featureName] || PAGINATION_SETTINGS_FEATURE_DEFAULTS[featureName];
+  }
+
+  private isFeatureEnabled({ rootGetters }: any, featureName: PaginationFeatureName): boolean {
+    return !!this.getFeature({ rootGetters }, featureName)?.enabled;
   }
 
   resourceChangesDebounceMs({ rootGetters }: any): number | undefined {

package/utils/release-notes.ts

@@ -20,7 +20,7 @@ export async function addReleaseNotesNotification(dispatch: any, getters: any) {
       if (notification.id === id) {
         found = true;
       } else {
-        await dispatch('notifications/delete', notification.id);
+        await dispatch('notifications/remove', notification.id);
       }
     }
   }