@rancher/shell 0.1.3 → 0.1.21

package/utils/__tests__/object.test.ts

@@ -38,18 +38,6 @@ describe('fx: get', () => {
     expect(result).toBeUndefined();
     expect(() => result).not.toThrow();
   });
-
-  it.each([
-    'key2.nonsense',
-    'non.sense',
-  ])('should catch error and return undefined', (path) => {
-    const obj = { key1: 'value', key2: { bat: 42, 'with.dots': 43 } };
-
-    const result = get(obj, path);
-
-    expect(result).toBeUndefined();
-    expect(() => result).not.toThrow();
-  });
 });
 
 describe('fx: getter', () => {
@@ -95,18 +83,6 @@ describe('fx: getter', () => {
       expect(result).toBeUndefined();
       expect(() => result).not.toThrow();
     });
-
-    it.each([
-      'key2.nonsense',
-      'non.sense',
-    ])('should catch error and return undefined', (path) => {
-      const obj = { key1: 'value', key2: { bat: 42, 'with.dots': 43 } };
-
-      const result = getter(path)(obj);
-
-      expect(result).toBeUndefined();
-      expect(() => result).not.toThrow();
-    });
   });
 });
 

package/utils/__tests__/selector.test.ts

@@ -171,7 +171,7 @@ describe('fx: parse', () => {
       ['!some.prefix/key-bar_baz '],
       ['! some.prefix/key-bar_baz '],
       [' !  some.prefix/key-bar_baz '],
-    ])('should parse expression %p to selector %p', (expression) => {
+    ])('should parse expression %p to selector %p using prefixes', (expression) => {
       const expected = {
         key:      'some.prefix/key-bar_baz',
         operator: 'DoesNotExist',

package/utils/dynamic-importer.js

@@ -107,6 +107,10 @@ export function resolveList(key) {
   return require.resolve(`@shell/list/${ key }`);
 }
 
+export function resolveChart(key) {
+  return require.resolve(`@shell/chart/${ key }`);
+}
+
 export function resolveEdit(key) {
   return require.resolve(`@shell/edit/${ key }`);
 }

package/utils/favicon.js

@@ -10,11 +10,17 @@ export function haveSetFavIcon() {
 export function setFavIcon(store) {
   const app = store.app;
   const res = store.getters['management/byId'](MANAGEMENT.SETTING, SETTING.FAVICON);
-
+  const brandSetting = store.getters['management/byId'](MANAGEMENT.SETTING, SETTING.BRAND);
   const link = findIconLink(app.head.link);
 
   if (link) {
-    link.href = res?.value || defaultFavIcon;
+    let brandImage;
+
+    if (brandSetting?.value === 'suse') {
+      brandImage = require('~shell/assets/brand/suse/favicon.png');
+    }
+
+    link.href = res?.value || brandImage || defaultFavIcon;
     favIconSet = true;
   }
 }

package/utils/gc/gc-interval.ts

@@ -0,0 +1,40 @@
+import gc from './gc';
+
+/**
+ * Kick of regular GC
+ */
+class GarbageCollectInterval {
+  private gcInterval?: NodeJS.Timer;
+
+  /**
+  * Request we start garbage collection at regular intervals
+  *
+  * If GC is disabled or running return early
+  */
+  gcStartIntervals(ctx: any) {
+    const { enabled, interval } = gc.gcEnabledInterval(ctx);
+
+    if (!gc.gcEnabledSetting(ctx) || !enabled) {
+      return;
+    }
+
+    if (this.gcInterval) {
+      return;
+    }
+
+    this.gcInterval = setInterval(() => {
+      ctx.dispatch('garbageCollect'); // gc.garbageCollect is per store, so dispatch via central point
+    }, interval * 1000);
+  }
+
+  gcStopIntervals() {
+    if (this.gcInterval) {
+      clearInterval(this.gcInterval);
+      delete this.gcInterval;
+    }
+  }
+}
+
+const gci = new GarbageCollectInterval();
+
+export default gci;

package/utils/gc/gc-root-store.js

@@ -0,0 +1,76 @@
+import gc from './gc';
+import gcInterval from './gc-interval';
+import gcRoute from './gc-route-changed';
+
+export const gcGetters = {
+  /**
+   * Fetch all stores that support garbage collection
+   */
+  gcStores(state) {
+    // It would be nice to grab all vuex module stores that we've registered, apparently this is only possible via the
+    // internal properties store._modules.root._children.
+    // So instead loop through all state entries to find the gc stores
+    return Object.entries(state).filter(([storeName, storeState]) => {
+      if (typeof (storeState) !== 'object') {
+        return;
+      }
+
+      if (!gc.gcEnabledForStore(storeState)) {
+        return;
+      }
+
+      return true;
+    });
+  }
+};
+
+export const gcActions = {
+  gcPreferencesUpdated({ dispatch }, { previouslyEnabled, newPreferences }) {
+    // Always stop the interval
+    // - GC Disabled, so it needs to stop
+    // - GC Enabled, we need to pick up new settings
+    dispatch('gcStopIntervals', { root: true });
+
+    if (newPreferences.enabled) {
+      // Cater for functionality that we get when the app loads
+      dispatch('gcStartIntervals', { root: true });
+    } else if (previouslyEnabled) {
+      // If we're going from enabled --> disabled we should reset any gc state we have stored. This avoids...
+      // - Last accessed times are stored
+      // - GC disabled so we don't update last accessed times
+      // - GC enabled and we have stale accessed times in the store
+      dispatch('gcResetStores', { root: true });
+    }
+  },
+
+  gcRouteChanged(ctx, to) {
+    gcRoute.gcRouteChanged(ctx, to);
+  },
+
+  gcStartIntervals(ctx) {
+    gcInterval.gcStartIntervals(ctx);
+  },
+
+  gcStopIntervals(ctx) {
+    gcInterval.gcStopIntervals();
+  },
+
+  gcResetStores({ dispatch, getters }) {
+    getters.gcStores.forEach(([storeName, storeState]) => {
+      dispatch(`${ storeName }/gcResetStore`);
+    });
+  },
+
+  /**
+   * Kick of a GC in all stores that support it
+   */
+  garbageCollect({ rootState, dispatch, getters }, ignoreTypes) {
+    if (!gc.gcEnabledSetting({ rootState })) {
+      return;
+    }
+
+    getters.gcStores.forEach(([storeName, storeState]) => {
+      dispatch(`${ storeName }/garbageCollect`, ignoreTypes);
+    });
+  }
+};

package/utils/gc/gc-route-changed.ts

@@ -0,0 +1,44 @@
+import gc from './gc';
+
+function getResourceFromRoute(to: any) {
+  let resource = to.params?.resource;
+
+  if ( !resource ) {
+    const match = to.name?.match(/^c-cluster-([^-]+)/);
+
+    if ( match ) {
+      resource = match[2];
+    }
+  }
+
+  return resource;
+}
+
+/**
+ * Handle GC on route change (given settings this might be a no-op)
+ */
+class GarbageCollectRouteChanged {
+  /**
+   * A logged in route has changed
+   * 1) Track the time this occurred to ensure any resources fetched afterwards are not GCd
+   * 2) Kick off a GC
+   */
+  gcRouteChanged(ctx: any, to: any) {
+    gc.gcUpdateRouteChanged();
+    // commit(`gcRouteChanged`);
+
+    if (!gc.gcEnabledSetting(ctx) || !gc.gcEnabledRoute(ctx) || to.name === 'auth-logout') {
+      // (auth-logout convenience, no point GC'ing if we've just lost all types)
+      return;
+    }
+
+    const resource = getResourceFromRoute(to);
+    const ignoreTYpes = !!resource ? { [resource]: true } : {};
+
+    ctx.dispatch('garbageCollect', ignoreTYpes); // gc.garbageCollect is per store, so dispatch via central point
+  }
+}
+
+const gcrc = new GarbageCollectRouteChanged();
+
+export default gcrc;

package/utils/gc/gc-types.ts

@@ -0,0 +1,21 @@
+export type GC_PREFERENCES = {
+  enabled: boolean,
+  enabledInterval: boolean,
+  interval: number,
+  enabledOnNavigate: boolean,
+  ageThreshold: number,
+  countThreshold: number
+}
+
+export const GC_DEFAULTS: GC_PREFERENCES = {
+  enabled: false,
+
+  // When GC Runs
+  enabledInterval:   true,
+  interval:          1 * 60 * 5,
+  enabledOnNavigate: true,
+
+  // How GC handles resources when GC'ing
+  ageThreshold:   1 * 60 * 2,
+  countThreshold:  500,
+};

package/utils/gc/gc.ts

@@ -0,0 +1,282 @@
+import { SETTING } from '@shell/config/settings';
+import { COUNT, MANAGEMENT } from '@shell/config/types';
+import { GC_DEFAULTS, GC_PREFERENCES } from './gc-types';
+
+class GarbageCollect {
+  private static ENABLE_DEBUG_LOGGING = false;
+
+  /**
+   * Don't run GC if it's been run within 5 seconds
+   */
+  private static GC_RE_RUN_GAP = 1000 * 5;
+
+  private cachedGcPrefs: GC_PREFERENCES = GC_DEFAULTS;
+
+  private cachedGcPrefsStamp: string = '';
+
+  private debugLog = (...args: any) => {
+    if (GarbageCollect.ENABLE_DEBUG_LOGGING) {
+      console.debug('GC', ...args); // eslint-disable-line no-console
+    }
+  };
+
+  /**
+   * Time the GC last ran
+   */
+  private gcLastRun: number | null = 0;
+
+  /**
+   * To avoid JSON.parse on the `ui-performance` setting keep a local cache
+   */
+  private getUiPerfGarbageCollection = (rootState: any) => {
+    const uiPerfSetting = rootState.management.types[MANAGEMENT.SETTING].list.find((s: any) => s.id === SETTING.UI_PERFORMANCE);
+
+    if (!uiPerfSetting || !uiPerfSetting.value) {
+      // Could be in the process of logging out
+      return undefined;
+    }
+    const stamp = `${ uiPerfSetting.metadata.generation }-${ uiPerfSetting.metadata.resourceVersion }`;
+
+    if (this.cachedGcPrefsStamp !== stamp) {
+      this.debugLog(`Updating ${ SETTING.UI_PERFORMANCE } cache`);
+      this.cachedGcPrefsStamp = stamp;
+      const uiPerfSettingParsed = JSON.parse(uiPerfSetting.value);
+
+      this.cachedGcPrefs = uiPerfSettingParsed.garbageCollection;
+    }
+
+    return this.cachedGcPrefs;
+  };
+
+  /**
+   * The last time a resource was accessed by either find or getters style functions
+   */
+  private lastAccessedCache: {
+    [store: string]: {
+      [type: string]: number;
+    }
+  } = {}
+
+  /**
+   * Track when a logged in route changes.
+   */
+  private lastRouteChange: number = 0;
+
+  // ------------- GC Enabled ---------------------
+
+  gcEnabledAll(pseudoCtx: any, type: string) {
+    return this.gcEnabledForStore(pseudoCtx.state) && this.gcEnabledSetting(pseudoCtx) && this.gcEnabledForType(pseudoCtx, type);
+  }
+
+  gcEnabledSetting(pseudoCtx: any) {
+    const { rootState } = pseudoCtx;
+
+    // Don't use a getter... as we'll end up triggering ourselves again
+    const uiPerfGarbageCollection = this.getUiPerfGarbageCollection(rootState);
+
+    return uiPerfGarbageCollection?.enabled;
+  }
+
+  gcEnabledForStore(state: any) {
+    return state?.config?.supportsGc;
+  }
+
+  /**
+   * Store can require certain types are not GC'd (for example `cluster` and `schema`s, `counts`, etc)
+   */
+  gcEnabledForType(pseudoCtx: any, type: string) {
+    const { getters } = pseudoCtx;
+
+    if (!type || getters.gcIgnoreTypes[type]) {
+      return false;
+    }
+
+    return true;
+  }
+
+  gcEnabledInterval(pseudoCtx: any) {
+    const { rootState } = pseudoCtx;
+
+    // Don't use a getter... as we'll end up triggering ourselves again
+    const uiPerfGarbageCollection = this.getUiPerfGarbageCollection(rootState);
+
+    return {
+      enabled:  uiPerfGarbageCollection?.enabledInterval,
+      interval: uiPerfGarbageCollection?.interval || 0
+    };
+  }
+
+  gcEnabledRoute(pseudoCtx: any) {
+    const { rootState } = pseudoCtx;
+
+    // Don't use a getter... as we'll end up triggering ourselves again
+    const uiPerfGarbageCollection = this.getUiPerfGarbageCollection(rootState);
+
+    return uiPerfGarbageCollection?.enabledOnNavigate;
+  }
+
+  // ------------- GC (actual) ---------------------
+
+  /**
+   * Remove stale resource types from the store and stop watching them for changes
+   */
+  garbageCollect(ctx: any, ignoreTypes: {[type: string]: boolean} = {}) {
+    const now = new Date().getTime();
+
+    // Is gc currently running OR has run in the past GC_RE_RUN_GAP return early
+    if (this.gcLastRun === null || now - this.gcLastRun < GarbageCollect.GC_RE_RUN_GAP) {
+      this.debugLog('Skipping (running or recently run)', this.gcLastRun ? new Date(this.gcLastRun) : 'running');
+
+      return;
+    }
+
+    this.gcLastRun = null;
+    const gcd: {[type: string]: number} = {};
+
+    try {
+      const { getters, rootState, dispatch } = ctx;
+
+      if (!rootState.clusterReady) {
+        this.debugLog('Skipping (cluster not ready)');
+        this.gcLastRun = new Date().getTime();
+
+        return ;
+      }
+      this.debugLog(`------ Started ------`);
+
+      const uiPerfGarbageCollection = this.getUiPerfGarbageCollection(rootState);
+
+      if (!uiPerfGarbageCollection) {
+        return ;
+      }
+      const maxAge = uiPerfGarbageCollection.ageThreshold * 1000;
+      const maxCount = uiPerfGarbageCollection.countThreshold;
+
+      this.debugLog(`Max Age: ${ maxAge }. Max Count: ${ maxCount }`);// , 'Cache', this.lastAccessedCache
+
+      const store = ctx.state.config.namespace;
+
+      // this.debugLog('Cache', this.lastAccessedCache);
+
+      Object.entries((this.lastAccessedCache[store] || {})).forEach(([type, lastAccessed]) => {
+        if (!lastAccessed) {
+          // There's no last accessed time... gc is probably disabled in another way
+          this.debugLog(`${ type }: Skipping (no accessed time)`);
+
+          return;
+        }
+
+        if (!this.gcEnabledForType(ctx, type)) {
+          // This specific store is telling us to ignore the type (for example `cluster` store will not GC schema's, counts, etc)
+          this.debugLog(`${ type }: Skipping (type ignored by store)`);
+
+          return;
+        }
+
+        if (ignoreTypes[type]) {
+          // We're going to a place that needs the resource
+          this.debugLog(`${ type }: Skipping (navigating to type)`);
+
+          return;
+        }
+
+        if (now - lastAccessed <= maxAge) {
+          // The resource was recently accessed
+
+          this.debugLog(`${ type }: Skipping (recently accessed)`);
+
+          return;
+        }
+
+        if (this.lastRouteChange !== undefined && this.lastRouteChange < lastAccessed ) {
+          // The resource is being used in the current route/page
+          this.debugLog(`${ type }: Skipping (used in current route/page)`);
+
+          return;
+        }
+
+        const countFromResource = getters.all(COUNT)[0].counts[type]?.summary.count;
+        const currentCount = countFromResource ?? 0;
+
+        if (currentCount === undefined || currentCount < maxCount) {
+          // There's too few resources, we might as well keep them to avoid a network request when we need them again
+          this.debugLog(`${ type }: Skipping (too few of resource)`);
+
+          return;
+        }
+
+        this.debugLog(`${ type }: Removing from store`);
+        dispatch('forgetType', type);
+        gcd[type] = currentCount;
+      });
+
+      this.gcLastRun = new Date().getTime();
+    } catch (e) {
+      this.debugLog(`: Error`, e);
+      this.gcLastRun = new Date().getTime();
+    }
+
+    if (Object.keys(gcd).length > 0) {
+      console.info('Garbage Collected Resources', gcd); // eslint-disable-line no-console
+    }
+
+    this.debugLog(`------ Finished ------`);
+  }
+
+  // ------------- GC Update local cache ---------------------
+
+  /**
+   * Update the time that the resource type was accessed
+   * This needs to run after any type initialisation (aka registerType)
+   */
+  gcUpdateLastAccessed(pseudoCtx: any, type: string) {
+    if (!this.gcEnabledAll(pseudoCtx, type)) {
+      return;
+    }
+    const store = pseudoCtx.state.config.namespace;
+
+    if (!this.lastAccessedCache[store]) {
+      this.lastAccessedCache[store] = {};
+    }
+
+    this.lastAccessedCache[store][type] = new Date().getTime();
+  }
+
+  /**
+   * Update the time the user last changed routes
+   */
+  gcUpdateRouteChanged() {
+    this.lastRouteChange = new Date().getTime();
+  }
+
+  // ------------- GC reset ---------------------
+
+  /**
+   * Remove all cached access times for the given store
+   */
+  gcResetStore(state: any) {
+    const store = state.config.namespace;
+
+    delete this.lastAccessedCache[store];
+
+    this.debugLog('Forgetting Store:', store);
+  }
+
+  /**
+   * Remove cached access time for the given resource type
+   */
+  gcResetType(state: any, type: string) {
+    const store = state.config.namespace;
+
+    if (!this.lastAccessedCache[store]) {
+      return;
+    }
+    delete this.lastAccessedCache[store][type];
+
+    this.debugLog('Forgetting Type:', store, type);
+  }
+}
+
+const gc = new GarbageCollect();
+
+export default gc;

package/utils/grafana.js

@@ -1,5 +1,5 @@
+import { haveV2Monitoring } from '@shell/utils/monitoring';
 import { parse as parseUrl, addParam } from '@shell/utils/url';
-import { MONITORING } from '@shell/config/types';
 
 export function computeDashboardUrl(embedUrl, clusterId, params) {
   const url = parseUrl(embedUrl);
@@ -21,7 +21,7 @@ export function computeDashboardUrl(embedUrl, clusterId, params) {
 }
 
 export async function dashboardExists(store, clusterId, embedUrl, storeName = 'cluster') {
-  if (!isMonitoringInstalled(store.getters, storeName)) {
+  if ( !haveV2Monitoring(store.getters) ) {
     return false;
   }
 
@@ -81,7 +81,3 @@ export async function failedProposals(dispatch, clusterId) {
 
   return response.data.result[0]?.values?.[0]?.[1] || 0;
 }
-
-function isMonitoringInstalled(getters, storeName = 'cluster') {
-  return !!getters[`${ storeName }/schemaFor`](MONITORING.SERVICEMONITOR);
-}