dashboard-shell-shell 3.0.2-rc.105 → 3.0.5-test.1

package/utils/grafana.js

@@ -24,6 +24,7 @@ export function computeDashboardUrl(monitoringVersion, embedUrl, clusterId, para
   }
   newUrl = addParam(newUrl, 'orgId', url.query.orgId);
   newUrl = addParam(newUrl, 'kiosk', null);
+  newUrl = addParam(newUrl, '_dash.hideTimePicker', 'true');
 
   Object.entries(params).forEach((entry) => {
     newUrl = addParam(newUrl, entry[0], entry[1]);

package/utils/kontainer.ts

@@ -17,11 +17,9 @@ export function syncUpstreamConfig(configPrefix: string, normanCluster: {[key: s
 
   if (!isEmpty(upstreamConfig)) {
     Object.keys(upstreamConfig).forEach((key) => {
-      if (typeof upstreamConfig[key] === 'object') {
-        if (isEmpty(rancherConfig[key]) && !isEmpty(upstreamConfig[key])) {
-          set(rancherConfig, key, upstreamConfig[key]);
-        }
-      } else if ((rancherConfig[key] === null || rancherConfig[key] === undefined) && upstreamConfig[key] !== null && upstreamConfig[key] !== undefined) {
+      const empty = typeof upstreamConfig[key] === 'object' && isEmpty(upstreamConfig[key]);
+
+      if ((rancherConfig[key] === null || rancherConfig[key] === undefined) && upstreamConfig[key] !== null && upstreamConfig[key] !== undefined && !empty) {
         set(rancherConfig, key, upstreamConfig[key]);
       }
     });

package/utils/object.js

@@ -510,10 +510,6 @@ export function deepToRaw(obj, cache = new WeakSet()) {
  *                  with arrays in obj2 when both properties are arrays
  *                  false: default lodash merge behavior - recursively merges
  *                  array members
- * @param {boolean} [options.replaceObjectProps=false] - true: merges objects in
- *                  obj1 with objects in obj2, overwriting duplicate props
- *                  false: default lodash merge behavior - recursively merges
- *                  object props
  */
 export function mergeWithReplace(
   obj1 = {},
@@ -521,7 +517,6 @@ export function mergeWithReplace(
   {
     mutateOriginal = false,
     replaceArray = true,
-    replaceObjectProps = false,
   } = {}
 ) {
   const destination = mutateOriginal ? obj1 : {};
@@ -530,12 +525,41 @@ export function mergeWithReplace(
     if (replaceArray && Array.isArray(obj1Value) && Array.isArray(obj2Value)) {
       return obj2Value;
     }
-
-    if (replaceObjectProps && isObject(obj1Value) && isObject(obj2Value)) {
-      return {
-        ...obj1Value,
-        ...obj2Value,
-      };
-    }
   });
 }
+/**
+ * Converts Object into a string of a format "key1, val1, key2, val2"
+ * @param {Object} input - KV object to convert
+ * @returns string
+ */
+export const convertKVToString = (input) => {
+  if (!input || typeof input !== 'object') return '';
+
+  return Object.entries(input)
+    .flatMap(([key, value]) => [key, String(value)])
+    .join(',');
+};
+
+/**
+ * Converts kv string into object
+ * @param {string} input - a string of a format "key1, val1, key2, val2"
+ * @returns
+ */
+export const convertStringToKV = ( input ) => {
+  if (!input?.trim()) return {};
+
+  const parts = input.split(',').map((part) => part.trim());
+  const result = {};
+
+  for (let i = 0; i < parts.length - 1; i += 2) {
+    const key = parts[i];
+    const value = parts[i + 1];
+
+    // Accept empty keys but ignore undefined values
+    if (typeof key === 'string') {
+      result[key] = value ?? '';
+    }
+  }
+
+  return result;
+};

package/utils/pagination-utils.ts

@@ -1,4 +1,4 @@
-import { PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
+import { PaginationFeature, PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
 import {
   NAMESPACE_FILTER_ALL_USER as ALL_USER,
   NAMESPACE_FILTER_ALL as ALL,
@@ -15,17 +15,22 @@ import { isEqual } from '@shell/utils/object';
 import { STEVE_CACHE } from '@shell/store/features';
 import { getPerformanceSetting } from '@shell/utils/settings';
 import { PAGINATION_SETTINGS_STORE_DEFAULTS } from '@shell/plugins/steve/steve-pagination-utils';
+import { MANAGEMENT } from '@shell/config/types';
 
 /**
  * Helper functions for server side pagination
  */
 class PaginationUtils {
+  /**
+   * In places where we're using paginated features but not in a page... this is what the max results should be
+   */
+  readonly defaultPageSize = 100000;
   /**
    * When a ns filter isn't one or more projects/namespaces... what are the valid values?
    *
    * This basically blocks 'Not in a Project'.. which would involve a projectsornamespaces param with every ns not in a project.
    */
-  validNsProjectFilters = [ALL, ALL_SYSTEM, ALL_USER, ALL_SYSTEM, NAMESPACE_FILTER_KINDS.NAMESPACE, NAMESPACE_FILTER_KINDS.PROJECT, NAMESPACED_YES, NAMESPACED_NO];
+  readonly validNsProjectFilters = [ALL, ALL_SYSTEM, ALL_USER, ALL_SYSTEM, NAMESPACE_FILTER_KINDS.NAMESPACE, NAMESPACE_FILTER_KINDS.PROJECT, NAMESPACED_YES, NAMESPACED_NO];
 
   private getSettings({ rootGetters }: any): PaginationSettings {
     const perf = getPerformanceSetting(rootGetters);
@@ -50,6 +55,23 @@ class PaginationUtils {
     return rootGetters['features/get']?.(STEVE_CACHE);
   }
 
+  /**
+   * Determine if the downstream cluster has vai enabled
+   *
+   * Almost all the time the downstream cluster vai state will align with upstream (it manages it)
+   * ... unless it's harvester then weird things happen
+   */
+  async isDownstreamSteveCacheEnabled({ dispatch }: any, clusterId: string): Promise<boolean> {
+    const url = `/k8s/clusters/${ clusterId }/v1/${ MANAGEMENT.FEATURE }s/${ STEVE_CACHE }`;
+    const entry = await dispatch('cluster/request', { url });
+
+    if (entry.status.lockedValue !== null) {
+      return entry.status.lockedValue;
+    }
+
+    return (entry.spec.value !== null) ? entry.spec.value : entry.status.default;
+  }
+
   /**
    * Is pagination enabled at a global level or for a specific resource
    */
@@ -62,7 +84,7 @@ class PaginationUtils {
     const settings = this.getSettings({ rootGetters });
 
     // No setting, not enabled
-    if (!settings?.enabled) {
+    if (!settings) {
       return false;
     }
 
@@ -124,6 +146,31 @@ class PaginationUtils {
     return false;
   }
 
+  listAutoRefreshToggleEnabled({ rootGetters }: any): boolean {
+    return this.isFeatureEnabled({ rootGetters }, 'listAutoRefreshToggle');
+  }
+
+  isListManualRefreshEnabled({ rootGetters }: any): boolean {
+    return this.isFeatureEnabled({ rootGetters }, 'listManualRefresh');
+  }
+
+  private isFeatureEnabled({ rootGetters }: any, featureName: PaginationFeature): boolean {
+    // Cache must be enabled to support pagination api
+    if (!this.isSteveCacheEnabled({ rootGetters })) {
+      return false;
+    }
+
+    const settings = this.getSettings({ rootGetters });
+
+    return !!settings.features?.[featureName]?.enabled;
+  }
+
+  resourceChangesDebounceMs({ rootGetters }: any): number | undefined {
+    const settings = this.getSettings({ rootGetters });
+
+    return settings.resourceChangesDebounceMs;
+  }
+
   validateNsProjectFilters(nsProjectFilters: string[]) {
     return nsProjectFilters?.every((f) => this.validateNsProjectFilter(f));
   }

package/utils/pagination-wrapper.ts

@@ -1,70 +1,152 @@
 import paginationUtils from '@shell/utils/pagination-utils';
-import { PaginationArgs, PaginationResourceContext, StorePagination } from '@shell/types/store/pagination.types';
+import { PaginationArgs, PaginationResourceContext } from '@shell/types/store/pagination.types';
 import { VuexStore } from '@shell/types/store/vuex';
-import { ActionFindPageArgs } from '@shell/types/store/dashboard-store.types';
+import { ActionFindPageArgs, ActionFindPageTransientResult } from '@shell/types/store/dashboard-store.types';
+import {
+  STEVE_WATCH_EVENT_LISTENER_CALLBACK, STEVE_UNWATCH_EVENT_PARAMS, STEVE_WATCH_EVENT, STEVE_WATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_PARAMS_COMMON, STEVE_WATCH_MODE
+} from '@shell/types/store/subscribe.types';
+import { Reactive, reactive } from 'vue';
 
-interface Result<T> {
-  data: Array<T>
-  pagination: StorePagination
+interface Args {
+  $store: VuexStore,
+  /**
+   * Unique ID for this request. Used for watch purposes
+   */
+  id: string,
+  /**
+   * Args used when determining if this resource type supports SSP
+   */
+  enabledFor: PaginationResourceContext,
+  /**
+   * Callback called when the resource is changed (notified by socket)
+   */
+  onChange?: () => void,
+
+  formatResponse?: {
+    /**
+     * Convert the response into a model class instance
+     */
+    classify?: boolean,
+    reactive?: boolean,
+  }
+}
+
+interface Result<T> extends Omit<ActionFindPageTransientResult<T>, 'data'> {
+  data: Reactive<T[]>
 }
 
 /**
- * This is a helper class that will assist in fetching a resource
- * - Handle if the resource can be fetched by the new pagination api
- * - Make a request to get a page (including classify)
- * - Provide updates when the resource changes
+ * This is a helper class that will assist in fetching a resource via the new Server-Side Pagination API
  *
  * This is designed to work in places where we don't/can't store the resource in the store
  * - There already exists a resource we don't want to overwrite
- * - We're transient and want something nicer than just cluster/request
+ * - We're transient and want something nicer than just `cluster/request` + all the trimmings
+ *
+ * It ...
+ * - Handles if the resource can be fetched by the new pagination api
+ * - Makes a request to get a page (including optional classify & reactive)
+ * - Provide updates when the resource changes
  */
-class PaginationWrapper<T = any> {
-    private $store: VuexStore;
-    private enabledFor: PaginationResourceContext;
-
-    // Blocked on https://github.com/rancher/rancher/issues/40773 / https://github.com/rancher/dashboard/issues/12734
-    private onUpdate: (out: Result<T>) => void;
-
-    public isEnabled: boolean;
-
-    constructor({
-      $store,
-      enabledFor,
-      onUpdate,
-    }: {
-        $store: VuexStore,
-        onUpdate: (res: Result<T>) => void,
-        enabledFor: PaginationResourceContext,
-    }) {
-      this.$store = $store;
-      this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters }, enabledFor);
-      this.enabledFor = enabledFor;
-      this.onUpdate = onUpdate;
+class PaginationWrapper<T extends object> {
+  private $store: VuexStore;
+  private enabledFor: PaginationResourceContext;
+  private onChange?: STEVE_WATCH_EVENT_LISTENER_CALLBACK;
+  private id: string;
+  private classify: boolean;
+  private reactive: boolean;
+
+  public isEnabled: boolean;
+  private steveWatchParams: STEVE_WATCH_EVENT_PARAMS_COMMON | undefined;
+
+  constructor(args: Args) {
+    const {
+      $store, id, enabledFor, onChange, formatResponse
+    } = args;
+
+    this.$store = $store;
+    this.id = id;
+    this.enabledFor = enabledFor;
+    this.onChange = onChange;
+    this.classify = formatResponse?.classify || false;
+    this.reactive = formatResponse?.reactive || false;
+
+    this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters }, enabledFor);
+  }
+
+  async request(args: {
+      pagination: PaginationArgs,
+  }): Promise<Result<T>> {
+    if (!this.isEnabled) {
+      throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ this.enabledFor.resource?.id }' in context '${ this.enabledFor.resource?.context }' not supported`);
+    }
+    const { pagination } = args;
+    const opt: ActionFindPageArgs = {
+      watch:     false,
+      pagination,
+      transient: true,
+    };
+
+    // Fetch
+    const out: ActionFindPageTransientResult<T> = await this.$store.dispatch(`${ this.enabledFor.store }/findPage`, { opt, type: this.enabledFor.resource?.id });
+
+    // Watch
+    if (this.onChange && !this.steveWatchParams) {
+      this.steveWatchParams = {
+        event:  STEVE_WATCH_EVENT.CHANGES,
+        id:     this.id,
+        params: {
+          type: this.enabledFor.resource?.id as string,
+          mode: STEVE_WATCH_MODE.RESOURCE_CHANGES,
+        }
+      };
+
+      this.watch();
     }
 
-    async request(args: {
-        pagination: PaginationArgs,
-        classify?: boolean,
-    }): Promise<Result<T>> {
-      if (!this.isEnabled) {
-        throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ this.enabledFor.resource?.id }' in context '${ this.enabledFor.resource?.context }' not supported`);
-      }
-      const { pagination, classify: doClassify } = args;
-      const opt: ActionFindPageArgs = {
-        transient: true,
-        pagination
+    // Convert Response
+    if (this.classify) {
+      out.data = await this.$store.dispatch(`${ this.enabledFor.store }/createMany`, out.data);
+    }
+
+    if (this.reactive) {
+      return {
+        ...out,
+        data: reactive(out.data)
       };
+    }
 
-      const out: Result<T> = await this.$store.dispatch(`${ this.enabledFor.store }/findPage`, { opt, type: this.enabledFor.resource?.id });
+    return out;
+  }
 
-      if (doClassify) {
-        for (let i = 0; i < out.data.length; i++) {
-          out.data[i] = await this.$store.dispatch(`${ this.enabledFor.store }/create`, out.data[i]);
-        }
-      }
+  private async watch() {
+    if (!this.steveWatchParams) {
+      console.error('Calling watch but no watch params created'); // eslint-disable-line no-console
 
-      return out;
+      return;
     }
+    const watchParams: STEVE_WATCH_EVENT_PARAMS = {
+      ...this.steveWatchParams,
+      callback: this.onChange as STEVE_WATCH_EVENT_LISTENER_CALLBACK, // we must have it by now
+    };
+
+    await this.$store.dispatch(`${ this.enabledFor.store }/watchEvent`, watchParams);
+  }
+
+  private async unWatch() {
+    if (!this.steveWatchParams) {
+      console.error('Calling unWatch but no watch params created'); // eslint-disable-line no-console
+
+      return;
+    }
+
+    const unWatchParams: STEVE_UNWATCH_EVENT_PARAMS = { ...this.steveWatchParams };
+
+    await this.$store.dispatch(`${ this.enabledFor.store }/unwatchEvent`, unWatchParams);
+  }
+
+  async onDestroy() {
+    await this.unWatch();
+  }
 }
 
 export default PaginationWrapper;

package/utils/perf-setting.utils.ts

@@ -0,0 +1,28 @@
+import { PerfSettings } from '@shell/config/settings';
+
+type PaginationSupersedesSettings = 'incrementalLoading' | 'manualRefresh'
+
+class _Utils {
+  private setting: PaginationSupersedesSettings;
+  constructor(setting: PaginationSupersedesSettings) {
+    this.setting = setting;
+  }
+
+  /**
+   * This is a centralised point to ensure SSP takes precedence over the performance setting
+   */
+  isEnabled(paginationEnabled: boolean, perfSettings: PerfSettings): boolean {
+    return !paginationEnabled && perfSettings[this.setting].enabled;
+  }
+}
+
+export default {
+  /**
+   * Helper functions for the 'incremental loading indicator' performance settings
+   */
+  incrementalLoadingUtils: new _Utils('incrementalLoading'),
+  /**
+   * Helper functions for the 'manual refresh' performance settings
+   */
+  manualRefreshUtils:      new _Utils('manualRefresh'),
+};

package/utils/release-notes.ts

@@ -0,0 +1,48 @@
+import { getVersionData } from '@shell/config/version';
+import { READ_WHATS_NEW } from '@shell/store/prefs';
+import { NotificationLevel } from '@shell/types/notifications';
+
+export async function addReleaseNotesNotification(dispatch: any, getters: any) {
+  const rancherVersion = getVersionData().Version.split('-')[0];
+  const prefix = 'release-notes-';
+  const id = `${ prefix }${ rancherVersion }`;
+  let found = false;
+  const all = getters['notifications/all'];
+  const lastReadVersion = getters['prefs/get'](READ_WHATS_NEW) || '';
+  const t = getters['i18n/t'];
+  const releaseNotesUrl = getters['releaseNotesUrl'];
+
+  // Delete notification(s) for old release notes
+  for (let i = 0; i < all.length; i++) {
+    const notification = all[i];
+
+    if (notification.id.startsWith(prefix)) {
+      if (notification.id === id) {
+        found = true;
+      } else {
+        await dispatch('notifications/delete', notification.id);
+      }
+    }
+  }
+
+  // Also use pref, so if we expired it, we don't add it back
+  if (!found && lastReadVersion !== rancherVersion) {
+    // Register notification
+    const notification = {
+      id,
+      level:      NotificationLevel.Info,
+      title:      t('landing.whatsNew.title', { version: rancherVersion }),
+      message:    t('landing.whatsNew.message'),
+      preference: {
+        key:   READ_WHATS_NEW,
+        value: rancherVersion
+      },
+      primaryAction: {
+        label:  t('landing.whatsNew.link'),
+        target: releaseNotesUrl
+      }
+    };
+
+    await dispatch('notifications/add', notification);
+  }
+}

package/utils/router.js

@@ -1,7 +1,7 @@
 import { INSTALL_REDIRECT_META_KEY } from '@shell/config/router/navigation-guards/install-redirect';
 
 export function harvesterhci2cloud(str) {
-  return str?.replace('harvesterhci.io', 'cloudhci.io')
+    return str?.replace('harvesterhci.io', 'cloudhci.io')
 }
 
 export function cloud2harvesterhci(str) {
@@ -14,11 +14,11 @@ export function cloud2harvesterhci(str) {
 }
 
 export function harvester2cloud(str) {
-  return str?.replace(/harvester/g, 'cloud');
+    return str?.replace('harvester', 'cloud')
 }
 
 export function cloud2harvester(str) {
-  return str?.replace(/cloud/g, 'harvester');
+    return str?.replace('cloud', 'harvester')
 }
 
 export function queryParamsFor(current, qp, defaults = {}) {
@@ -89,7 +89,7 @@ export const getPackageFromRoute = (route) => {
 };
 
 export const getResourceFromRoute = (to) => {
-  let resource = cloud2harvesterhci(to.params?.resource);
+  let resource = to.params?.resource;
 
   if (!resource) {
     resource = findMeta(to, 'resource');