@rancher/shell 3.0.7 → 3.0.8-rc.1

package/utils/dynamic-content/info.ts

@@ -0,0 +1,219 @@
+/**
+ * Helper for collecting system information and formatting into to a query string
+ */
+
+import { sha256 } from '@shell/utils/crypto';
+import {
+  COUNT,
+  MANAGEMENT,
+} from '@shell/config/types';
+import { SETTING } from '@shell/config/settings';
+import { getVersionData } from '@shell/config/version';
+import { SettingsInfo } from '@shell/utils/dynamic-content/types';
+
+const QS_VERSION = 'v1'; // Include a version number in the query string in case we want to version the set of params we are sending
+const UNKNOWN = 'unknown';
+
+// List of known UI extensions from SUSE
+const SUSE_EXTENSIONS = [
+  'capi',
+  'elemental',
+  'harvester',
+  'kubewarden',
+  'neuvector-ui-ext',
+  'observability',
+  'supportability-review-app',
+  'virtual-clusters'
+];
+
+/**
+ * System information that is collected and which can then be encoded into a query string in the dyanmic content request
+ */
+type SystemInfo = {
+  systemUUID: string;
+  systemHash: string;
+  serverVersionType: string;
+  userHash: string;
+  version: string;
+  isDeveloperVersion: boolean;
+  isPrime: boolean;
+  isLTS: boolean;
+  clusterCount: number;
+  localCluster: any;
+  extensions?: {
+    knownInstalled: string[];
+    customCount: number;
+  };
+  browserSize: string;
+  screenSize: string;
+  language: string;
+};
+
+/**
+ * Helper that will gather system information and provided the `buildQueryString` method to format as a query string
+ */
+export class SystemInfoProvider {
+  private info: SystemInfo;
+
+  constructor(getters: any, settings: Partial<SettingsInfo>) {
+    this.info = this.getSystemData(getters, settings);
+  }
+
+  /**
+   * Get the data that we need from the system
+   * @param getters Store getters to access the store
+   * @returns System data
+   */
+  private getSystemData(getters: any, settingsInfo: Partial<SettingsInfo>): SystemInfo {
+    let url;
+    let systemUUID = UNKNOWN;
+    let serverVersionType = UNKNOWN;
+
+    const serverUrlSetting = getters['management/byId'](MANAGEMENT.SETTING, SETTING.SERVER_URL);
+
+    // Server URL
+    if (serverUrlSetting) {
+      url = serverUrlSetting.value || UNKNOWN;
+    }
+
+    // UUID
+    const uuidSetting = getters['management/byId'](MANAGEMENT.SETTING, 'install-uuid');
+
+    if (uuidSetting) {
+      systemUUID = uuidSetting.value || UNKNOWN;
+    }
+
+    // Server Version Type
+    const serverVersionTypeSetting = getters['management/byId'](MANAGEMENT.SETTING, 'server-version-type');
+
+    if (serverVersionTypeSetting) {
+      serverVersionType = serverVersionTypeSetting.value || UNKNOWN;
+    }
+
+    // Otherwise, use the window location's host
+    url = url || window.location?.host;
+
+    // System and User hashes
+    const systemHash = (sha256(url, 'hex') as string).substring(0, 32);
+    const currentPrincipal = getters['auth/principalId'] || UNKNOWN;
+    const userHash = (sha256(currentPrincipal, 'hex') as string).substring(0, 32);
+
+    // Version info
+    const versionData = getVersionData();
+    const vers = versionData.Version.split('-');
+
+    // General stats that can help us shape content delivery
+
+    // High-level information from clusters
+    const counts = this.getAll(getters, COUNT)?.[0]?.counts || {};
+    const clusterCount = counts[MANAGEMENT.CLUSTER] || {};
+    const all = this.getAll(getters, MANAGEMENT.CLUSTER);
+    const localCluster = all ? all.find((c: any) => c.isLocal) : undefined;
+
+    // Stats for installed extensions
+    const uiExtensionList = getters['uiplugins/plugins'];
+    let extensions;
+
+    if (uiExtensionList) {
+      const suseExtensions = [
+        ...SUSE_EXTENSIONS,
+        ...settingsInfo?.suseExtensions || []
+      ];
+      const notBuiltIn = uiExtensionList.filter((e: any) => !e.builtin);
+      const suseNames = notBuiltIn.filter((e: any) => suseExtensions.includes(e.name)).map((e: any) => e.name);
+      const customCount = notBuiltIn.length - suseNames.length;
+
+      extensions = {
+        knownInstalled: suseNames,
+        customCount,
+      };
+    }
+
+    const screenSize = `${ window.screen?.width || '?' }x${ window.screen?.height || '?' }`;
+    const browserSize = `${ window.innerWidth }x${ window.innerHeight }`;
+
+    return {
+      systemUUID,
+      userHash,
+      systemHash,
+      serverVersionType,
+      version:            vers[0],
+      isDeveloperVersion: vers.length > 1,
+      isPrime:            versionData.RancherPrime === 'true',
+      isLTS:              false,
+      clusterCount:       clusterCount?.summary?.count,
+      localCluster,
+      extensions,
+      screenSize,
+      browserSize,
+      language:           window.navigator?.language,
+    };
+  }
+
+  // Helper to get all resources of a type only if they are available
+  private getAll(getters: any, typeName: string): any {
+    if (getters['management/typeRegistered'](typeName)) {
+      return getters['management/all'](typeName);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Build query string of params to send so that we can deliver better content
+   */
+  public buildQueryString(): string {
+    const systemData = this.info;
+    const params = [`dcv=${ QS_VERSION }`];
+
+    // System and User
+    params.push(`s=${ systemData.systemHash }`);
+    params.push(`u=${ systemData.userHash }`);
+
+    // Install UUID
+    if (systemData.systemUUID !== UNKNOWN) {
+      params.push(`uuid=${ systemData.systemUUID }`);
+    }
+
+    // Server Version Type
+    if (systemData.serverVersionType !== UNKNOWN) {
+      params.push(`svt=${ systemData.serverVersionType }`);
+    }
+
+    // Version info
+    params.push(`v=${ systemData.version }`);
+    params.push(`dev=${ systemData.isDeveloperVersion }`);
+    params.push(`p=${ systemData.isPrime }`);
+
+    // Remove LTS for now, until we can determine LTS status
+    // params.push(`lts=${ systemData.isLTS }`);
+
+    // Clusters
+    params.push(`cc=${ systemData.clusterCount }`);
+
+    if (systemData.localCluster) {
+      params.push(`lkv=${ systemData.localCluster.kubernetesVersionBase || UNKNOWN }`);
+      params.push(`lcp=${ systemData.localCluster.provisioner || UNKNOWN }`);
+      params.push(`lnc=${ systemData.localCluster.status.nodeCount || 0 }`);
+    }
+
+    // Extensions
+    if (systemData.extensions) {
+      params.push(`xkn=${ systemData.extensions.knownInstalled.join(',') }`);
+      params.push(`xcc=${ systemData.extensions.customCount }`);
+    }
+
+    // Browser Language
+    params.push(`bl=${ systemData.language }`);
+
+    // Browser size
+    params.push(`bs=${ systemData.browserSize }`);
+
+    // Screen size
+    if (systemData.screenSize !== '?x?') {
+      params.push(`ss=${ systemData.screenSize }`);
+    }
+
+    return params.join('&');
+  }
+}

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

@@ -0,0 +1,126 @@
+/**
+ *
+ * The code in this file is responsible for adding New Release notifications driven off of the dynamic content metadata
+ *
+ * We handle two cases:
+ *
+ * 1. There is a new patch release available for the current Rancher version (e.g. user is in 2.12.0 and we release 2.12.1)
+ * 2. There is a new patch release available for the current Rancher version AND there is a newer version for a high minor releases
+ *    > this often occurs because we release monthly releases in parallel with the new minor releases
+ *
+ * We show slightly different messages in these 2 cases.
+ *
+ */
+
+import semver from 'semver';
+import { NotificationLevel } from '@shell/types/notifications';
+import { READ_NEW_RELEASE } from '@shell/store/prefs';
+import { Context, ReleaseInfo, VersionInfo } from './types';
+import { removeMatchingNotifications } from './util';
+
+export async function processReleaseVersion(context: Context, releaseInfo: ReleaseInfo[] | undefined, versionInfo: VersionInfo) {
+  if (!releaseInfo || !versionInfo?.version || !Array.isArray(releaseInfo)) {
+    return;
+  }
+
+  const { version } = versionInfo;
+  const versions = releaseInfo.map((v: any) => semver.coerce(v.name));
+
+  // Sort the versions, so that the newest is first in the list
+  versions.sort((a: any, b: any) => semver.gt(b, a) ? 1 : -1);
+
+  // Find first newer version
+  const newer = versions.find((v: any) => semver.gt(v, version));
+
+  // Find newest patch version for the current version (if available)
+  const newerPatch = versions.find((v: any) => {
+    const newVersion = semver.coerce(v);
+
+    return newVersion && newVersion.major === version.major && newVersion.minor === version.minor && semver.gt(v, version);
+  });
+
+  if (newer) {
+    context.logger.info(`Found a newer release: ${ newer.version }`);
+
+    if (newerPatch && newer !== newerPatch) {
+      context.logger.info(`Also found a newer patch release: ${ newerPatch.version }`);
+      // There is a new patch release and a newer release
+      await addNewMultipleReleasesNotification(context, newerPatch.version, newer.version);
+    } else {
+      // There is a new release (but no newer patch release)
+      await addNewReleaseNotification(context, newer.version);
+    }
+  }
+}
+
+async function addNewReleaseNotification(context: Context, version: string) {
+  const prefix = 'new-release-';
+  const releaseNotesUrl = context.settings.releaseNotesUrl.replace('$version', version);
+  const { dispatch, getters, logger } = context;
+
+  // TODO: Get the preference
+  const lastReadVersion = getters['prefs/get'](READ_NEW_RELEASE) || '';
+  const t = getters['i18n/t'];
+
+  // Delete notification(s) for old release notes
+  // This shouldn't happen normally, as we release less often than notifications should expire
+  if (!await removeMatchingNotifications(context, prefix, version) && lastReadVersion !== version) {
+    logger.debug(`Adding new release notification for ${ version } because one did not exist`);
+
+    const notification = {
+      id:         `${ prefix }${ version }`,
+      level:      NotificationLevel.Announcement,
+      title:      t('dynamicContent.newRelease.title', { version }),
+      message:    t('dynamicContent.newRelease.message', { version }),
+      preference: {
+        key:   READ_NEW_RELEASE,
+        value: version
+      },
+      primaryAction: {
+        label:  t('dynamicContent.newRelease.moreInfo'),
+        target: releaseNotesUrl
+      }
+    };
+
+    await dispatch('notifications/add', notification);
+  }
+}
+
+async function addNewMultipleReleasesNotification(context: Context, version1: string, version2: string) {
+  const prefix = 'new-release-';
+  const key = `${ version1 }-${ version2 }`;
+  const releaseNotesUrl1 = context.settings.releaseNotesUrl.replace('$version', version1);
+  const releaseNotesUrl2 = context.settings.releaseNotesUrl.replace('$version', version2);
+  const { dispatch, getters, logger } = context;
+
+  // TODO: Get the preference
+  const lastReadVersion = getters['prefs/get'](READ_NEW_RELEASE) || '';
+  const t = getters['i18n/t'];
+
+  // Delete notification(s) for old release notes
+  // This shouldn't happen normally, as we release less often than notifications should expire
+  if (!await removeMatchingNotifications(context, prefix, key) && lastReadVersion !== key) {
+    logger.info(`Adding new multiple release notification for ${ version1 } and ${ version2 }`);
+
+    const notification = {
+      id:         `${ prefix }${ key }`,
+      level:      NotificationLevel.Announcement,
+      title:      t('dynamicContent.multipleNewReleases.title'),
+      message:    t('dynamicContent.multipleNewReleases.message', { version1, version2 }),
+      preference: {
+        key:   READ_NEW_RELEASE,
+        value: key
+      },
+      primaryAction: {
+        label:  t('dynamicContent.multipleNewReleases.moreInfo', { version: version1 }),
+        target: releaseNotesUrl1
+      },
+      secondaryAction: {
+        label:  t('dynamicContent.multipleNewReleases.moreInfo', { version: version2 }),
+        target: releaseNotesUrl2
+      }
+    };
+
+    await dispatch('notifications/add', notification);
+  }
+}

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

@@ -0,0 +1,169 @@
+/**
+ *
+ * The code in this file is responsible for adding Support notifications driven off of the dynamic content metadata
+ *
+ * This covers these cases:
+ *
+ * 1. Current release has reached  End of Maintenance (EOL)
+ * 2. Current release has reached End of Maintenance (EOM)
+ * 3. Current release is approaching End of Maintenance (EOL)
+ * 4. Current release is approaching End of Maintenance (EOM)
+ *
+ * Note that we process in the order to that shown above, and stop at the first one that is active - so reaching EOL will show a notification
+ * and we won't look at the others.
+ *
+ */
+
+import semver from 'semver';
+import day from 'dayjs';
+import { NotificationLevel } from '@shell/types/notifications';
+import { READ_SUPPORT_NOTICE, READ_UPCOMING_SUPPORT_NOTICE } from '@shell/store/prefs';
+import { removeMatchingNotifications } from './util';
+import { Context, VersionInfo, UpcomingSupportInfo, SupportInfo } from './types';
+import { UPDATE_DATE_FORMAT } from './index';
+
+// Number of days ahead of upcoming EOM or EOL that we will notify the user
+const DEFAULT_UPCOMING_WINDOW = 30;
+
+// Prefixes used in the notifications IDs created here
+const SUPPORT_NOTICE_PREFIX = 'support-notice-';
+const UPCOMING_SUPPORT_NOTICE_PREFIX = 'upcoming-support-notice-';
+
+// Prefixes used in the value of the user preference to track which notifications the user has read
+const PREFIX = {
+  EOM: 'eom',
+  EOL: 'eol',
+};
+
+// Internal type used with convenience functions
+type Config = {
+  prefValuePrefix?: string;
+  pref: any;
+  notificationPrefix: string;
+  titleKey: string;
+  messageKey: string;
+};
+
+/**
+ * Main exported function that will process the support (stateInfo)
+ *
+ * @param context Context helper providing access to config, logger, store
+ * @param statusInfo Support information
+ * @param versionInfo Version information
+ */
+
+export async function processSupportNotices(context: Context, statusInfo: SupportInfo | undefined, versionInfo: VersionInfo): Promise<void> {
+  if (!statusInfo || !versionInfo?.version) {
+    return;
+  }
+
+  const { version } = versionInfo;
+  const { logger } = context;
+
+  // TODO: ****************************************************************************************
+  // TODO: Check if the user is an admin if we are Prime - we only notify admins of EOM and EOL
+  // TODO: ****************************************************************************************
+
+  const status = statusInfo.status || {};
+  const majorMinor = `${ semver.major(version) }.${ semver.minor(version) }`;
+
+  // Check if this version is EOL - we warn of EOL
+  // If a version is EOL, then is has passed EOM, so we don't need to check that
+  if (status.eol && semver.satisfies(version, status.eol)) {
+    logger.info(`This version (${ version }) is End of Life`);
+
+    return await checkAndAddNotification(context, {
+      prefValuePrefix:    PREFIX.EOL,
+      pref:               READ_SUPPORT_NOTICE,
+      notificationPrefix: SUPPORT_NOTICE_PREFIX,
+      titleKey:           'dynamicContent.eol.title',
+      messageKey:         'dynamicContent.eol.message',
+    }, majorMinor);
+  }
+
+  if (status.eom && semver.satisfies(version, status.eom)) {
+    logger.info(`This version (${ version }) is End of Maintenance`);
+
+    return await checkAndAddNotification(context, {
+      prefValuePrefix:    PREFIX.EOM,
+      pref:               READ_SUPPORT_NOTICE,
+      notificationPrefix: SUPPORT_NOTICE_PREFIX,
+      titleKey:           'dynamicContent.eom.title',
+      messageKey:         'dynamicContent.eom.message',
+    }, majorMinor);
+  }
+
+  // Now check for upcoming EOL or EOM
+
+  // Upcoming EOL
+  if (statusInfo.upcoming?.eol && semver.satisfies(version, statusInfo.upcoming.eol.version)) {
+    if (await checkAndAddUpcomingNotification(context, statusInfo.upcoming.eol, {
+      prefValuePrefix:    PREFIX.EOL,
+      pref:               READ_UPCOMING_SUPPORT_NOTICE,
+      notificationPrefix: UPCOMING_SUPPORT_NOTICE_PREFIX,
+      titleKey:           'dynamicContent.upcomingEol.title',
+      messageKey:         'dynamicContent.upcomingEol.message',
+    }, majorMinor)) {
+      return;
+    }
+  }
+
+  // Upcoming EOM
+  if (statusInfo.upcoming?.eom && semver.satisfies(version, statusInfo.upcoming.eom.version)) {
+    await checkAndAddUpcomingNotification(context, statusInfo.upcoming.eom, {
+      prefValuePrefix:    PREFIX.EOM,
+      pref:               READ_UPCOMING_SUPPORT_NOTICE,
+      notificationPrefix: UPCOMING_SUPPORT_NOTICE_PREFIX,
+      titleKey:           'dynamicContent.upcomingEom.title',
+      messageKey:         'dynamicContent.upcomingEom.message',
+    }, majorMinor);
+  }
+}
+
+async function checkAndAddUpcomingNotification(context: Context, info: UpcomingSupportInfo, config: Config, majorMinor: string): Promise<boolean> {
+  const now = day(day().format(UPDATE_DATE_FORMAT));
+  const upcomingDate = day(day(info.date).format(UPDATE_DATE_FORMAT));
+  const distance = upcomingDate.diff(now, 'day');
+  const noticeWindow = info.noticeDays || DEFAULT_UPCOMING_WINDOW;
+
+  // If we've passed the upcoming date, then ignore, as this should have been covered by the eom status
+  if (distance > 0 && distance < noticeWindow) {
+    await checkAndAddNotification(context, config, majorMinor, distance);
+
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Check if a notification already exists or has already been read and if not, add it
+ *
+ * @param context Context helper providing access to config, logger, store
+ * @param config Configuration for the notification
+ * @param majorMinor Major.Minor version number
+ * @param distance Number of days until the event occurs (for upcoming support events)
+ */
+async function checkAndAddNotification(context: Context, config: Config, majorMinor: string, distance?: number) {
+  const { dispatch, getters, logger } = context;
+  const t = getters['i18n/t'];
+  const lastReadNotice = getters['prefs/get'](config.pref) || '';
+  const prefValue = config.prefValuePrefix ? `${ config.prefValuePrefix }-${ majorMinor }` : majorMinor;
+
+  if (!await removeMatchingNotifications(context, config.notificationPrefix, prefValue) && lastReadNotice !== prefValue) {
+    const notification = {
+      id:         `${ config.notificationPrefix }${ prefValue }`,
+      level:      NotificationLevel.Warning,
+      title:      t(config.titleKey, { version: majorMinor, days: distance }),
+      message:    t(config.messageKey, { version: majorMinor, days: distance }),
+      preference: {
+        key:   config.pref,
+        value: prefValue
+      },
+    };
+
+    logger.info(`Adding support notification for ${ majorMinor } (${ config.notificationPrefix }${ config.prefValuePrefix })`);
+
+    await dispatch('notifications/add', notification);
+  }
+}

package/utils/dynamic-content/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Shared types for Dynamic Content
+ */
+
+import { SemVer } from 'semver';
+
+/**
+ * Logger interface for dynamic content
+ */
+export interface Logger {
+  error: Function,
+  info: Function,
+  debug: Function,
+}
+
+/**
+ * Distribution type
+ */
+export type Distribution = 'community' | 'prime';
+
+/**
+ * Dynamic Content configuration
+ */
+export type Configuration = {
+  enabled: boolean;
+  debug: boolean;
+  log: boolean;
+  endpoint: string;
+  prime: boolean;
+  distribution: Distribution;
+};
+
+/**
+ * Settings configuration that can be supplied in the dynamic content package
+ */
+export type SettingsInfo = {
+  releaseNotesUrl: string; // URL format to use when generating release note links for new releases
+  suseExtensions: string[]; // Names of extra SUSE UI extensions on top of the list built-in
+  debugVersion?: string;
+};
+
+/**
+ * Common context passed through various functions
+ */
+export type Context = {
+  dispatch: Function,
+  getters: any,
+  axios: any,
+  logger: Logger,
+  isAdmin: boolean,
+  config: Configuration,
+  settings: SettingsInfo,
+};
+
+/**
+ * Version information
+ */
+export type VersionInfo = {
+  version: SemVer | null;
+  isPrime: boolean;
+};
+
+/**
+ * Information for a new release
+ */
+export type ReleaseInfo = {
+  name: string;
+};
+
+/**
+ * Information for an upcoming release
+ */
+export type UpcomingSupportInfo = {
+  version: string, // Version number: semver (e.g. '<= 2.12')
+  date: Date, // Date when the eom/eol takes place (note, only the day part is used, time is ignored)
+  noticeDays?: number, // Number of days in advance to notify the user (if not specified, the default is used)
+};
+
+/**
+ * Support information covering current EOM/EOL and upcoming EOM/EOL information
+ */
+export type SupportInfo = {
+  status: {
+    eom: string,
+    eol: string,
+  },
+  upcoming: {
+    eom: UpcomingSupportInfo,
+    eol: UpcomingSupportInfo,
+  }
+};
+
+/**
+ * Main type for the metadata that is retrieved from the dynamic content endpoint
+ */
+export type DynamicContent = {
+  version: string;
+  releases: ReleaseInfo[],
+  support: SupportInfo,
+  settings?: Partial<SettingsInfo>,
+};