@rancher/shell 0.3.0 → 0.3.2

package/utils/__tests__/object.test.ts

@@ -1,4 +1,6 @@
-import { clone, get, getter, isEmpty } from '@shell/utils/object';
+import {
+  clone, get, getter, isEmpty, toDictionary
+} from '@shell/utils/object';
 
 describe('fx: get', () => {
   describe('should return value of an object', () => {
@@ -126,3 +128,17 @@ describe('fx: isEmpty', () => {
     expect(result).toBe(expected);
   });
 });
+
+describe('fX: toDictionary', () => {
+  it('should return a dictionary from an array', () => {
+    const array = ['a', 'b', 'c'];
+    const asd = (value: string) => value.toUpperCase();
+    const expectation = {
+      a: 'A', b: 'B', c: 'C'
+    };
+
+    const result = toDictionary(array, asd);
+
+    expect(result).toStrictEqual(expectation);
+  });
+});

package/utils/__tests__/pod-security-admission.test.ts

@@ -0,0 +1,61 @@
+import { PSA } from '@shell/types/pod-security-admission';
+import { getPSATooltipsDescription } from '@shell/utils/pod-security-admission';
+
+describe('fX: getPSATooltipsDescription', () => {
+  it('should return empty object if no labels', () => {
+    const resource = { metadata: { labels: {} } } as Partial<PSA> as PSA;
+
+    const result = getPSATooltipsDescription(resource);
+
+    expect(result).toStrictEqual({});
+  });
+
+  it('should return prettified dictionary of labels', () => {
+    const resource = { metadata: { labels: { 'pod-security.kubernetes.io/enforce': 'restricted' } } } as Partial<PSA> as PSA;
+
+    const result = getPSATooltipsDescription(resource);
+
+    expect(result).toStrictEqual({ 'pod-security.kubernetes.io/enforce': 'Enforce Restricted (latest)' });
+  });
+
+  it('should exclude non-PSA labels', () => {
+    const resource = {
+      metadata: {
+        labels: {
+          'field.cattle.io/projectId':          'p-68z77',
+          'kubernetes.io/metadata.name':        'psa-test-ns',
+          'pod-security.kubernetes.io/enforce': 'privileged',
+          bananas:                              'potatoes'
+        },
+      }
+    } as Partial<PSA> as PSA;
+
+    const result = getPSATooltipsDescription(resource);
+
+    expect(result).toStrictEqual({ 'pod-security.kubernetes.io/enforce': 'Enforce Privileged (latest)' });
+  });
+
+  it('should return prettified dictionary of labels with version', () => {
+    const version = '1.0.0';
+    const resource = {
+      metadata: {
+        labels: {
+          'pod-security.kubernetes.io/enforce':         'privileged',
+          'pod-security.kubernetes.io/enforce-version': version
+        }
+      }
+    } as Partial<PSA> as PSA;
+
+    const result = getPSATooltipsDescription(resource);
+
+    expect(result).toStrictEqual({ 'pod-security.kubernetes.io/enforce': `Enforce Privileged (${ version })` });
+  });
+
+  it(`should return prettified dictionary of labels with 'latest' as default version if none`, () => {
+    const resource = { metadata: { labels: { 'pod-security.kubernetes.io/enforce': 'privileged' } } } as Partial<PSA> as PSA;
+
+    const result = getPSATooltipsDescription(resource);
+
+    expect(result).toStrictEqual({ 'pod-security.kubernetes.io/enforce': `Enforce Privileged (latest)` });
+  });
+});

package/utils/async.ts

@@ -0,0 +1,36 @@
+export const waitFor = (testFn: Function, msg = '', timeoutMs = 3000000, intervalMs = 500, log = false) => {
+  gatedLog('Starting wait for', msg);
+
+  return new Promise((resolve, reject) => {
+    if (testFn()) {
+      gatedLog('Wait for', msg || 'unknown', 'done immediately');
+      resolve(this);
+    }
+    const timeout = setTimeout(() => {
+      gatedLog('Wait for', msg, 'timed out');
+      clearInterval(interval);
+      clearTimeout(timeout);
+      if (msg) {
+        reject(new Error(`Failed waiting for: ${ msg }`));
+      } else {
+        throw new Error(`waitFor timed out after ${ timeoutMs / 1000 } seconds`);
+      }
+    }, timeoutMs);
+    const interval = setInterval(() => {
+      if ( testFn() ) {
+        gatedLog('Wait for', msg, 'done');
+        clearInterval(interval);
+        clearTimeout(timeout);
+        resolve(this);
+      } else if (msg) {
+        gatedLog('Wait for', msg, 'not done yet');
+      }
+    }, intervalMs);
+  });
+
+  function gatedLog(...args: any[]) {
+    if (log) {
+      console.log(...args); // eslint-disable-line no-console
+    }
+  }
+};

package/utils/color.js

@@ -63,6 +63,11 @@ const DARK_CONTRAST_COLORS = {
 
 };
 
+const STANDARD_COLORS = {
+  black: '#000000',
+  white: '#ffffff',
+};
+
 // contrastColor(color, {light, dark}) returns which of 2 options is higher contrast with color
 export function contrastColor(color, contrastOptions = LIGHT_CONTRAST_COLORS) {
   let out = contrastOptions.light;
@@ -90,3 +95,43 @@ export function textColor(color) {
 
   return (brightness > 125) ? 'black' : 'white';
 }
+
+export function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : null;
+}
+
+export function mapStandardColors(color) {
+  return STANDARD_COLORS[color] || color;
+}
+
+export function rgbToRgb(rgb) {
+  const result = /^rgb\(([0-9]{1,3}),\s*([0-9]{1,3}),\s*([0-9]{1,3})\)$/i.exec(rgb);
+
+  return result ? {
+    r: parseInt(result[1], 10),
+    g: parseInt(result[2], 10),
+    b: parseInt(result[3], 10)
+  } : null;
+}
+
+export function colorToRgb(color) {
+  let value;
+
+  if (color.startsWith('rgb(')) {
+    value = rgbToRgb(color);
+  } else if (color.startsWith('#')) {
+    value = hexToRgb(color);
+  } else {
+    console.warn(`Unable to parse color: ${ color }`); // eslint-disable-line no-console
+  }
+
+  return value || {
+    r: 0, g: 0, b: 0
+  };
+}

package/utils/crypto/browserHashUtils.js

@@ -1,5 +1,23 @@
 import { Buffer } from 'buffer';
 
+function hashString(str) {
+  let hash = 0;
+
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+
+    hash = (hash << 5) - hash + char;
+    hash &= hash;
+  }
+
+  return new Uint32Array([hash])[0].toString(36);
+}
+
+// Quick, simple hash function to generate hash for an object
+export function hashObj(obj) {
+  return hashString(JSON.stringify(obj, null, 2));
+}
+
 /**
  * @api private
  */

package/utils/dynamic-importer.js

@@ -122,3 +122,11 @@ export function resolveDetail(key) {
 export function resolveWindowComponent(key) {
   return require.resolve(`@shell/components/nav/WindowManager/${ key }`);
 }
+
+export function resolveMachineConfigComponent(key) {
+  return require.resolve(`@shell/machine-config/${ key }`);
+}
+
+export function resolveCloudCredentialComponent(key) {
+  return require.resolve(`@shell/cloud-credential/${ key }`);
+}

package/utils/install-redirect.js

@@ -26,7 +26,7 @@ export default function(product, chartName, defaultResourceOrRoute, install = tr
     } else if (install) {
       // The product is not installed, redirect to the details chart
 
-      await store.dispatch('catalog/load');
+      await store.dispatch('catalog/load', { force: true });
 
       const chart = store.getters['catalog/chart']({ chartName });
 

package/utils/object.js

@@ -353,3 +353,27 @@ export function applyChangeset(obj, changeset) {
 
   return obj;
 }
+
+/**
+ * Creates an object composed of the `object` properties `predicate` returns
+ */
+export function pickBy(obj = {}, predicate = (value, key) => false) {
+  return Object.entries(obj)
+    .reduce((res, [key, value]) => {
+      if (predicate(value, key)) {
+        res[key] = value;
+      }
+
+      return res;
+    }, {});
+}
+
+/**
+ * Convert list to dictionary from a given function
+ * @param {*} array
+ * @param {*} callback
+ * @returns
+ */
+export const toDictionary = (array, callback) => Object.assign(
+  {}, ...array.map(item => ({ [item]: callback(item) }))
+);

package/utils/pod-security-admission.ts

@@ -0,0 +1,39 @@
+import { reduce, filter, keys } from 'lodash';
+import { PSALabelPrefix, PSALabelsNamespaces } from '@shell/config/pod-security-admission';
+import { camelToTitle } from '@shell/utils/string';
+import { PSA } from '@shell/types/pod-security-admission';
+
+/**
+ * Return PSA labels present in the resource
+ * @returns string[]
+ */
+export const getPSALabels = (resource: PSA): string[] => filter(keys(resource?.metadata?.labels), key => PSALabelsNamespaces.includes(key));
+
+/**
+ * Return boolean value if the label is a PSA label
+ * @returns Boolean
+ */
+export const hasPSALabels = (resource: PSA): boolean => getPSALabels(resource).length > 0;
+
+/**
+ * Generate tooltips dictionary from a given PSA namespaced label pair of key and values
+ */
+export const getPSATooltipsDescription = (resource: PSA): Record<string, string> => reduce(
+  resource?.metadata?.labels,
+  (acc, value, key) => {
+    const isPSA = PSALabelsNamespaces.includes(key);
+
+    // Retrieve version from paired label ending with `-version`
+    const suffix = '-version';
+    const isVersionLabel = key.includes(suffix);
+    const versionLabel = resource?.metadata?.labels[`${ key }${ suffix }`];
+    const version = versionLabel || 'latest';
+
+    // Add SPA labels and discard paired version label
+    return isPSA && !isVersionLabel ? {
+      ...acc,
+      [key]: `${ camelToTitle(key.replace(PSALabelPrefix, '')) } ${ camelToTitle(value) } (${ version })`
+    } : acc;
+  },
+  { }
+);

package/utils/socket.js

@@ -10,8 +10,9 @@ const INSECURE = 'ws://';
 const SECURE = 'wss://';
 
 const STATE_DISCONNECTED = 'disconnected';
-const STATE_CONNECTING = 'connecting';
-const STATE_CONNECTED = 'connected';
+
+export const STATE_CONNECTING = 'connecting';
+export const STATE_CONNECTED = 'connected';
 const STATE_CLOSING = 'closing';
 const STATE_RECONNECTING = 'reconnecting';
 
@@ -23,6 +24,9 @@ export const EVENT_FRAME_TIMEOUT = 'frame_timeout';
 export const EVENT_CONNECT_ERROR = 'connect_error';
 export const EVENT_DISCONNECT_ERROR = 'disconnect_error';
 
+export const NO_WATCH = 'NO_WATCH';
+export const NO_SCHEMA = 'NO_SCHEMA';
+
 export default class Socket extends EventTarget {
   url;
   autoReconnect = true;
@@ -33,6 +37,7 @@ export default class Socket extends EventTarget {
   protocol = null;
   maxTries = null;
   tries = 0;
+  idAsTimestamp = false;
 
   // "Private"
   socket = null;
@@ -40,11 +45,11 @@ export default class Socket extends EventTarget {
   framesReceived = 0;
   frameTimer;
   reconnectTimer;
-  disconnectCbs = [];
+  disconnectCallBacks = [];
   disconnectedAt = 0;
   closingId = 0;
 
-  constructor(url, autoReconnect = true, frameTimeout = null, protocol = null, maxTries = null) {
+  constructor(url, autoReconnect = true, frameTimeout = null, protocol = null, maxTries = null, idAsTimestamp = false) {
     super();
 
     this.setUrl(url);
@@ -53,6 +58,7 @@ export default class Socket extends EventTarget {
     // maxTries = null === never stop trying to reconnect
     // allow maxTries to be defined on individual sockets bc not all will clearly warn the user that we've stopped trying
     this.maxTries = maxTries;
+    this.idAsTimestamp = idAsTimestamp;
 
     if ( frameTimeout !== null ) {
       this.frameTimeout = frameTimeout;
@@ -84,10 +90,10 @@ export default class Socket extends EventTarget {
 
     Object.assign(this.metadata, metadata);
 
-    const id = sockId++;
+    const id = this.idAsTimestamp ? new Date().getTime() : sockId++;
     const url = addParam(this.url, 'sockId', id);
 
-    console.log(`Socket connecting (id=${ id }, url=${ `${ url.replace(/\?.*/, '') }...` })`); // eslint-disable-line no-console
+    this._baseLog('connecting', { id, url: url.replace(/\?.*/, '') });
 
     let socket;
 
@@ -122,9 +128,9 @@ export default class Socket extends EventTarget {
     return false;
   }
 
-  disconnect(cb) {
-    if ( cb ) {
-      this.disconnectCbs.push(cb);
+  disconnect(callBack) {
+    if ( callBack ) {
+      this.disconnectCallBacks.push(callBack);
     }
 
     const self = this;
@@ -140,7 +146,7 @@ export default class Socket extends EventTarget {
 
       this.addEventListener(EVENT_CONNECT_ERROR, onError);
 
-      this.disconnectCbs.push(() => {
+      this.disconnectCallBacks.push(() => {
         this.removeEventListener(EVENT_CONNECT_ERROR, onError);
         resolve();
       });
@@ -208,7 +214,7 @@ export default class Socket extends EventTarget {
       socket.onmessage = null;
       socket.close();
     } catch (e) {
-      this._log('Socket exception', e);
+      this._log('exception', { e: e.toString() });
       // Continue anyway...
     }
 
@@ -256,7 +262,7 @@ export default class Socket extends EventTarget {
 
     if ( timeout && this.state === STATE_CONNECTED) {
       this.frameTimer = setTimeout(() => {
-        this._log('Socket watchdog expired after', timeout, 'closing');
+        this._log(`watchdog expired after${ timeout }. Closing`);
         this._close();
         this.dispatchEvent(new CustomEvent(EVENT_FRAME_TIMEOUT));
       }, timeout);
@@ -268,17 +274,22 @@ export default class Socket extends EventTarget {
     this._log('error');
   }
 
-  _closed() {
-    console.log(`Socket ${ this.closingId } closed`); // eslint-disable-line no-console
+  _closed(event) {
+    const { code, reason, wasClean } = event;
+
+    this._baseLog('closed', {
+      id: this.closingId || this.socket?.sockId || 'unknown', code, reason, clean: wasClean
+    });
+
     this.closingId = 0;
     this.socket = null;
     clearTimeout(this.reconnectTimer);
     clearTimeout(this.frameTimer);
 
-    const cbs = this.disconnectCbs;
+    const callBacks = this.disconnectCallBacks;
 
-    while ( cbs.length ) {
-      const fn = cbs.pop();
+    while ( callBacks.length ) {
+      const fn = callBacks.pop();
 
       if ( fn ) {
         fn.apply(this);
@@ -305,17 +316,19 @@ export default class Socket extends EventTarget {
       this.state = STATE_RECONNECTING;
 
       if (this.maxTries && this.tries > 1 && this.tries <= this.maxTries) {
-        // dispatch an event which will trigger a growl from steve-plugin sockets warning users that we've lost connection and are attemping to reconnect
+        // dispatch an event which will trigger a growl from steve-plugin sockets warning users that we've lost connection and are attempting to reconnect
         const e = new CustomEvent(EVENT_CONNECT_ERROR);
 
         this.dispatchEvent(e);
       }
 
       if (this.maxTries && this.tries > this.maxTries) {
+        this._log('closed. Will not reconnect (hit max attempts)');
         this.state = STATE_DISCONNECTED;
         // dispatch an event which will trigger a growl from steve-plugin sockets warning users that we've given up trying to reconnect
         this.dispatchEvent(new CustomEvent(EVENT_DISCONNECT_ERROR));
       } else {
+        this._log('closed. Attempting to reconnect');
         const delay = Math.max(1000, Math.min(1000 * this.tries, 30000));
 
         this.reconnectTimer = setTimeout(() => {
@@ -333,13 +346,37 @@ export default class Socket extends EventTarget {
     }
   }
 
-  _log(...args) {
-    const message = JSON.parse(JSON.stringify([...args]));
-
-    message.unshift('Socket');
+  /**
+   * `console.log` the provided summary statement, with default information to identify the socket and the provided props
+   */
+  _log(summary, props) {
+    this._baseLog(summary, {
+      state: this.state, id: this.socket?.sockId || 0, ...props
+    });
+  }
 
-    message.push(`(state=${ this.state }, id=${ this.socket ? this.socket.sockId : 0 })`);
+  /**
+   * `console.log` the provided summary statement and props
+   *
+   * This does not contain information to identify the socket and can be used in scenarios where it's not known or default
+   */
+  _baseLog(summary, props) {
+    const message = [summary];
+    const values = Object.entries(props || {});
+
+    message.unshift('Socket ');
+
+    if (values.length) {
+      message.push(' (');
+      values.forEach(([key, value], index) => {
+        if (index !== 0) {
+          message.push(`, `);
+        }
+        message.push(`${ key }=${ value }`);
+      });
+      message.push(')');
+    }
 
-    console.log(message.join(' ')); // eslint-disable-line no-console
+    console.log(message.join('')); // eslint-disable-line no-console
   }
 }

package/utils/string.js

@@ -129,6 +129,8 @@ export function formatPercent(value, maxPrecision = 2) {
 export function pluralize(str) {
   if ( str.match(/.*[^aeiou]y$/i) ) {
     return `${ str.substr(0, str.length - 1) }ies`;
+  } else if ( str.endsWith('ics') ) {
+    return str;
   } else if ( str.endsWith('s') ) {
     return `${ str }es`;
   } else {