@rancher/shell 3.0.7 → 3.0.8-rc.10

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

@@ -0,0 +1,235 @@
+import { removeMatchingNotifications, createLogger, LOCAL_STORAGE_CONTENT_DEBUG_LOG } from '../util';
+import { Context, Configuration } from '../types';
+
+describe('util.ts', () => {
+  describe('removeMatchingNotifications', () => {
+    let mockContext: Context;
+    let mockDispatch: jest.Mock;
+    let mockGetters: any;
+    let mockLogger: any;
+
+    beforeEach(() => {
+      mockDispatch = jest.fn();
+      mockGetters = { 'notifications/all': [] };
+      mockLogger = { debug: jest.fn() };
+      mockContext = {
+        dispatch: mockDispatch,
+        getters:  mockGetters,
+        logger:   mockLogger,
+        // The following properties are not used by this function but are required by the type
+        axios:    {},
+        isAdmin:  true,
+        config:   {} as any,
+        settings: {} as any,
+      };
+    });
+
+    it('should return false and not remove anything if no notifications exist', async() => {
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(false);
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('should return false and not remove anything if no notifications match the prefix', async() => {
+      mockGetters['notifications/all'] = [
+        { id: 'other-1' },
+        { id: 'other-2' },
+      ];
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(false);
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('should return true and not remove anything if the current notification is the only one matching', async() => {
+      mockGetters['notifications/all'] = [
+        { id: 'prefix-current' },
+        { id: 'other-1' },
+      ];
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(true);
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('should return false and remove a notification that matches the prefix but not the currentId', async() => {
+      mockGetters['notifications/all'] = [
+        { id: 'prefix-old' },
+        { id: 'other-1' },
+      ];
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(false);
+      expect(mockDispatch).toHaveBeenCalledTimes(1);
+      expect(mockDispatch).toHaveBeenCalledWith('notifications/remove', 'prefix-old');
+    });
+
+    it('should return true and remove old notifications when the current one also exists', async() => {
+      mockGetters['notifications/all'] = [
+        { id: 'prefix-old-1' },
+        { id: 'prefix-current' },
+        { id: 'prefix-old-2' },
+        { id: 'other-1' },
+      ];
+      const found = await removeMatchingNotifications(mockContext, 'prefix-', 'current');
+
+      expect(found).toBe(true);
+      expect(mockDispatch).toHaveBeenCalledTimes(2);
+      expect(mockDispatch).toHaveBeenCalledWith('notifications/remove', 'prefix-old-1');
+      expect(mockDispatch).toHaveBeenCalledWith('notifications/remove', 'prefix-old-2');
+    });
+  });
+
+  describe('createLogger / log', () => {
+    let mockLocalStorage: { [key: string]: string };
+    let consoleErrorSpy: jest.SpyInstance;
+    let consoleInfoSpy: jest.SpyInstance;
+    let consoleDebugSpy: jest.SpyInstance;
+    let dispatchEventSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      // Mock localStorage
+      mockLocalStorage = {};
+      jest.spyOn(Storage.prototype, 'getItem').mockImplementation((key) => mockLocalStorage[key] || null);
+      jest.spyOn(Storage.prototype, 'setItem').mockImplementation((key, value) => {
+        mockLocalStorage[key] = value;
+      });
+
+      // Mock console
+      consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+      consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => {});
+      consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {});
+
+      // Mock dispatchEvent
+      dispatchEventSpy = jest.spyOn(window, 'dispatchEvent').mockImplementation(() => true);
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should always log errors to console, but only to localStorage if config.log is true', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: false, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      logger.error('test error');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('test error');
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeUndefined();
+
+      // Test with arg
+      logger.error('test error', 'with arg');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('test error', 'with arg');
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeUndefined();
+
+      config.log = true;
+
+      logger.error('test error with log');
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('test error with log');
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeDefined();
+      expect(JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG])[0].message).toBe('test error with log');
+    });
+
+    it('should log info to console and localStorage only if config.log is true', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: false, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      logger.info('test info');
+
+      expect(consoleInfoSpy).not.toHaveBeenCalled();
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeUndefined();
+
+      config.log = true;
+      logger.info('test info with log');
+
+      expect(consoleInfoSpy).toHaveBeenCalledWith('test info with log');
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeDefined();
+      expect(JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG])[0].message).toBe('test info with log');
+
+      // Test with arg
+      logger.info('test info', 'with arg');
+
+      expect(consoleInfoSpy).toHaveBeenCalledWith('test info', 'with arg');
+    });
+
+    it('should log debug to console only if config.debug is true, and localStorage if config.log is true', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: false, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      logger.debug('test debug');
+      expect(consoleDebugSpy).not.toHaveBeenCalled();
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeUndefined();
+
+      config.log = true;
+      logger.debug('test debug with log');
+      expect(consoleDebugSpy).not.toHaveBeenCalled();
+      expect(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]).toBeDefined();
+      expect(JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG])[0].message).toBe('test debug with log');
+
+      config.debug = true;
+      logger.debug('test debug with debug and log');
+      expect(consoleDebugSpy).toHaveBeenCalledWith('test debug with debug and log');
+    });
+
+    it('should dispatch a custom event when logging to localStorage', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: true, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      logger.info('test event');
+
+      expect(dispatchEventSpy).toHaveBeenCalledTimes(1);
+      const event = dispatchEventSpy.mock.calls[0][0] as CustomEvent;
+
+      expect(event.type).toBe('dynamicContentLog');
+      expect(event.detail.message).toBe('test event');
+    });
+
+    it('should limit the number of log messages in localStorage', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: true, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      // MAX_LOG_MESSAGES is 50
+      for (let i = 0; i < 60; i++) {
+        logger.info(`message ${ i }`);
+      }
+
+      const logs = JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]);
+
+      expect(logs).toHaveLength(50);
+      expect(logs[0].message).toBe('message 59'); // Most recent
+      expect(logs[49].message).toBe('message 10'); // Oldest
+    });
+
+    it('should not throw if localStorage is corrupted', () => {
+      const config: Configuration = {
+        enabled: true, debug: false, log: true, endpoint: '', prime: false, distribution: 'community'
+      };
+      const logger = createLogger(config);
+
+      mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG] = 'this is not valid json';
+
+      expect(() => {
+        logger.info('test message');
+      }).not.toThrow();
+
+      // It should have overwritten the bad data
+      const logs = JSON.parse(mockLocalStorage[LOCAL_STORAGE_CONTENT_DEBUG_LOG]);
+
+      expect(logs).toHaveLength(1);
+      expect(logs[0].message).toBe('test message');
+    });
+  });
+});

package/utils/dynamic-content/announcement.ts

@@ -0,0 +1,142 @@
+/**
+ *
+ * The code in this file is responsible for adding 'announcement 'notifications driven off of the dynamic content metadata
+ *
+ * Announcements will be able to be shown in different places in the UI
+ *
+ */
+
+import semver from 'semver';
+import { NotificationLevel, Notification } from '@shell/types/notifications';
+import { READ_ANNOUNCEMENTS } from '@shell/store/prefs';
+import { Context, VersionInfo, Announcement } from './types';
+import { DynamicContentAnnouncementHandlerName } from './notification-handler';
+
+// Prefixes used in the notifications IDs created here
+export const ANNOUNCEMENT_PREFIX = 'announcement-';
+
+const TARGET_NOTIFICATION_CENTER = 'notification';
+const TARGET_HOME_PAGE = 'homepage';
+const ALLOWED_TARGETS = [TARGET_NOTIFICATION_CENTER, TARGET_HOME_PAGE];
+
+const ALLOWED_NOTIFICATIONS: Record<string, NotificationLevel> = {
+  announcement: NotificationLevel.Announcement,
+  info:         NotificationLevel.Info,
+  warning:      NotificationLevel.Warning,
+  homepage:     NotificationLevel.Hidden,
+};
+
+/**
+ * Main exported function that will process the announcements
+ *
+ * @param context Context helper providing access to config, logger, store
+ * @param announcements Announcement information
+ * @param versionInfo Version information
+ */
+export async function processAnnouncements(context: Context, announcements: Announcement[] | undefined, versionInfo: VersionInfo): Promise<void> {
+  if (!announcements || !announcements.length || !versionInfo?.version) {
+    return;
+  }
+
+  const { dispatch, getters, logger } = context;
+
+  // Process each announcement
+  await Promise.all(announcements.map(async(announcement: Announcement) => {
+    // Check version
+    if (announcement.version && !semver.satisfies(versionInfo.version, announcement.version)) {
+      return;
+    }
+
+    // Check audience (currently only admin or all, but may add more in the future)
+    if (announcement.audience === 'admin' && !context.isAdmin) {
+      return;
+    }
+
+    if (!announcement.id) {
+      logger.error(`No ID For announcement - not going to add a notification for the announcement`);
+
+      return;
+    }
+
+    // Check type
+    const targetSplit = announcement.target.split('/');
+    const target = targetSplit[0];
+
+    // Make sure that the target is supported
+    if (ALLOWED_TARGETS.includes(target)) {
+      let level = NotificationLevel.Announcement;
+      let data: any = {};
+
+      if (target === TARGET_NOTIFICATION_CENTER) {
+        // Show a notification
+        const subType = targetSplit.length === 2 ? targetSplit[1] : 'announcement';
+
+        if (!(subType in ALLOWED_NOTIFICATIONS)) {
+          logger.error(`Announcement notification type ${ subType } is not supported`);
+
+          return;
+        }
+
+        level = ALLOWED_NOTIFICATIONS[subType];
+      } else if (target === TARGET_HOME_PAGE) {
+        level = NotificationLevel.Hidden;
+        data = {
+          icon:     announcement.icon,
+          location: targetSplit.length === 2 ? targetSplit[1] : 'banner',
+        };
+
+        if (announcement.style) {
+          data.style = announcement.style;
+        }
+      }
+
+      logger.info(`Going to add a notification for announcement ${ announcement.target }`);
+
+      // We should check if the notification already exists
+      const id = `${ ANNOUNCEMENT_PREFIX }${ announcement.id }`;
+      const existing = getters['notifications/item'](id);
+
+      // Check if the pref for 'read announcements' has the id
+      const pref = getters['prefs/get'](READ_ANNOUNCEMENTS) || '';
+      const prefExists = pref.split(',').includes(announcement.id);
+
+      if (existing || prefExists) {
+        logger.info(`Not adding announcement with ID ${ id } as it already exists or has been read previously (title: ${ announcement.title })`);
+
+        return;
+      }
+
+      const notification: Notification = {
+        id,
+        level,
+        title:       announcement.title,
+        message:     announcement.message,
+        handlerName: DynamicContentAnnouncementHandlerName,
+      };
+
+      if (data && Object.keys(data).length > 0) {
+        notification.data = data;
+      }
+
+      if (announcement.cta?.primary) {
+        notification.primaryAction = {
+          label:  announcement.cta.primary.action,
+          target: announcement.cta.primary.link,
+        };
+      }
+
+      if (announcement.cta?.secondary) {
+        notification.secondaryAction = {
+          label:  announcement.cta.secondary.action,
+          target: announcement.cta.secondary.link,
+        };
+      }
+
+      logger.info(`Adding announcement with ID ${ id } (title: ${ announcement.title }, target: ${ announcement.target })`);
+
+      await dispatch('notifications/add', notification);
+    } else {
+      logger.error(`Announcement type ${ announcement.target } is not supported`);
+    }
+  }));
+}

package/utils/dynamic-content/config.ts

@@ -0,0 +1,55 @@
+import { SETTING } from '@shell/config/settings';
+import { isRancherPrime } from '@shell/config/version';
+import { Configuration, Distribution } from './types';
+import { MANAGEMENT } from '@shell/config/types';
+
+// Default endpoint ($dist is either 'community' or 'prime')
+const DEFAULT_ENDPOINT = 'https://updates.rancher.io/rancher/$dist/updates';
+
+// We only support retrieving content from secure endpoints
+const HTTPS_PREFIX = 'https://';
+
+/**
+ * Get configuration data based on the distribution and Rancher settings
+ *
+ * @param getters Store getters to access the store
+ * @returns Dynamic Content configuration
+ */
+export function getConfig(getters: any): Configuration {
+  const prime = isRancherPrime();
+  const distribution: Distribution = prime ? 'prime' : 'community';
+
+  // Default configuration
+  const config: Configuration = {
+    enabled:  true,
+    debug:    false,
+    log:      false,
+    endpoint: DEFAULT_ENDPOINT,
+    prime,
+    distribution,
+  };
+
+  // Update 'enabled' and 'endpoint' from Rancher settings, if applicable
+  try {
+    const enabledSetting = getters['management/byId'](MANAGEMENT.SETTING, SETTING.DYNAMIC_CONTENT_ENABLED);
+
+    if (enabledSetting?.value) {
+      // Any value other than 'false' means enabled (can't disable on Prime)
+      config.enabled = config.prime ? enabledSetting.value !== 'false' : true;
+      config.debug = enabledSetting.value === 'debug';
+      config.log = enabledSetting.value === 'log' || config.debug;
+    }
+
+    // Can only override the url when Prime
+    const urlSetting = getters['management/byId'](MANAGEMENT.SETTING, SETTING.DYNAMIC_CONTENT_ENDPOINT);
+
+    // Are we Prime, do we have a URL and does the URL start with the https prefix? If so, use it
+    if (prime && urlSetting?.value && urlSetting.value.startsWith(HTTPS_PREFIX)) {
+      config.endpoint = urlSetting.value;
+    }
+  } catch (e) {
+    console.error('Error reading dynamic content settings', e); // eslint-disable-line no-console
+  }
+
+  return config;
+}

package/utils/dynamic-content/example.json

@@ -0,0 +1,40 @@
+{
+  "version": 1,
+  "releases": [
+    {
+      "name": "2.12.2"
+    },
+    {
+      "name": "2.11.3"
+    },
+    {
+      "name": "2.10.3"
+    }
+  ],
+  "announcements": [
+    {
+      "id": "security-update",
+      "target": "notification/announcement",
+      "title": "Important Security Update",
+      "message": "A critical security vulnerability has been discovered in version 2.10.1. Users are strongly advised to update to version 2.12.2 immediately to ensure their systems remain secure.",
+      "cta": {
+        "primary" : {
+          "action": "Update Now",
+          "link": "https://www.suse.com/"
+        }
+      }
+    },
+    {
+      "id": "suse-rocks",
+      "target": "homepage/banner",
+      "title": "Important Security Update",
+      "message": "A critical security vulnerability has been discovered in version 2.10.1. Users are strongly advised to update to version 2.12.2 immediately to ensure their systems remain secure.",
+      "cta": {
+        "primary" : {
+          "action": "Update Now",
+          "link": "https://www.suse.com/"
+        }
+      }
+    }
+  ]
+}