@rancher/shell 0.1.0

package/utils/socket.js

@@ -0,0 +1,315 @@
+import { EventTarget } from 'event-target-shim';
+import { isSafari } from '@shell/utils/platform';
+import { addParam } from '@shell/utils/url';
+
+let sockId = 1;
+let warningShown = false;
+let wasConnected = false;
+
+const INSECURE = 'ws://';
+const SECURE = 'wss://';
+
+const STATE_DISCONNECTED = 'disconnected';
+const STATE_CONNECTING = 'connecting';
+const STATE_CONNECTED = 'connected';
+const STATE_CLOSING = 'closing';
+const STATE_RECONNECTING = 'reconnecting';
+
+export const EVENT_CONNECTING = STATE_CONNECTING;
+export const EVENT_CONNECTED = STATE_CONNECTED;
+export const EVENT_DISCONNECTED = STATE_DISCONNECTED;
+export const EVENT_MESSAGE = 'message';
+export const EVENT_FRAME_TIMEOUT = 'frame_timeout';
+export const EVENT_CONNECT_ERROR = 'connect_error';
+
+export default class Socket extends EventTarget {
+  url;
+  autoReconnect = true;
+  frameTimeout = 35000;
+  metadata = {};
+  hasBeenOpen = false;
+  hasReconnected = false;
+  protocol = null;
+
+  // "Private"
+  socket = null;
+  state = STATE_DISCONNECTED;
+  framesReceived = 0;
+  frameTimer;
+  reconnectTimer;
+  tries = 0;
+  disconnectCbs = [];
+  disconnectedAt = 0;
+  closingId = 0;
+
+  constructor(url, autoReconnect = true, frameTimeout = null, protocol = null) {
+    super();
+
+    this.setUrl(url);
+    this.autoReconnect = autoReconnect;
+    this.protocol = protocol;
+
+    if ( frameTimeout !== null ) {
+      this.frameTimeout = frameTimeout;
+    }
+  }
+
+  setUrl(url) {
+    if ( !url.match(/wss?:\/\//) ) {
+      url = window.location.origin.replace(/^http/, 'ws') + url;
+    }
+
+    if ( window.location.protocol === 'https:' && url.startsWith(INSECURE) ) {
+      url = SECURE + url.substr(INSECURE.length);
+    }
+
+    this.url = url;
+  }
+
+  connect(metadata = {}) {
+    if ( this.socket ) {
+      console.error('Socket refusing to connect while another socket exists'); // eslint-disable-line no-console
+
+      return;
+    }
+
+    Object.assign(this.metadata, metadata);
+
+    const id = sockId++;
+    const url = addParam(this.url, 'sockId', id);
+
+    console.log(`Socket connecting (id=${ id }, url=${ `${ url.replace(/\?.*/, '') }...` })`); // eslint-disable-line no-console
+
+    let socket;
+
+    if ( this.protocol ) {
+      socket = new WebSocket(url, this.protocol);
+    } else {
+      socket = new WebSocket(url);
+    }
+
+    socket.sockId = id;
+    socket.metadata = this.metadata;
+    socket.onmessage = this._onmessage.bind(this);
+    socket.onopen = this._opened.bind(this);
+    socket.onerror = this._error.bind(this);
+    socket.onclose = this._closed.bind(this);
+
+    this.socket = socket;
+    this.state = STATE_CONNECTING;
+
+    this.dispatchEvent(new CustomEvent(EVENT_CONNECTING));
+  }
+
+  send(data) {
+    if ( this.socket && this.state === STATE_CONNECTED ) {
+      this.socket.send(data);
+
+      return true;
+    }
+
+    return false;
+  }
+
+  disconnect(cb) {
+    if ( cb ) {
+      this.disconnectCbs.push(cb);
+    }
+
+    const self = this;
+    const promise = new Promise((resolve, reject) => {
+      if ( this.state === STATE_DISCONNECTED ) {
+        resolve();
+      }
+
+      function onError(e) {
+        reject(e);
+        self.removeEventListener(EVENT_CONNECT_ERROR, onError);
+      }
+
+      this.addEventListener(EVENT_CONNECT_ERROR, onError);
+
+      this.disconnectCbs.push(() => {
+        this.removeEventListener(EVENT_CONNECT_ERROR, onError);
+        resolve();
+      });
+    });
+
+    this.autoReconnect = false;
+    this._close();
+
+    return promise;
+  }
+
+  reconnect(metadata = {}) {
+    Object.assign(this.metadata, metadata);
+
+    if ( this.state === STATE_CONNECTING ) {
+      this._log('Ignoring reconnect for socket in connecting');
+
+      return;
+    }
+
+    if ( this.socket ) {
+      this._close();
+    } else {
+      this.connect(metadata);
+    }
+  }
+
+  getMetadata() {
+    if ( this.socket ) {
+      return this.socket.metadata;
+    } else {
+      return {};
+    }
+  }
+
+  getId() {
+    if ( this.socket ) {
+      return this.socket.sockId;
+    } else {
+      return 0;
+    }
+  }
+
+  setAutoReconnect(autoReconnect) {
+    this.autoReconnect = autoReconnect;
+  }
+
+  // "Private"
+  _close() {
+    const socket = this.socket;
+
+    if ( !socket ) {
+      return;
+    }
+
+    try {
+      this._log('closing');
+      this.closingId = socket.sockId;
+      socket.onopen = null;
+      socket.onerror = null;
+      socket.onmessage = null;
+      socket.close();
+    } catch (e) {
+      this._log('Socket exception', e);
+      // Continue anyway...
+    }
+
+    this.state = STATE_CLOSING;
+  }
+
+  _opened() {
+    this._log('opened');
+    const now = (new Date()).getTime();
+
+    const at = this.disconnectedAt;
+    let after = 0;
+
+    if ( at ) {
+      after = now - at;
+    }
+
+    if ( this.hasBeenOpen ) {
+      this.hasReconnected = true;
+    }
+
+    this.hasBeenOpen = true;
+    this.state = STATE_CONNECTED;
+    this.framesReceived = 0;
+    this.disconnectedAt = 0;
+
+    this.dispatchEvent(new CustomEvent(EVENT_CONNECTED, { detail: { tries: this.tries, after } }));
+    this._resetWatchdog();
+    clearTimeout(this.reconnectTimer);
+  }
+
+  _onmessage(event) {
+    this._resetWatchdog();
+    this.tries = 0;
+    this.framesReceived++;
+
+    this.dispatchEvent(new CustomEvent(EVENT_MESSAGE, { detail: event }));
+  }
+
+  _resetWatchdog() {
+    clearTimeout(this.frameTimer);
+
+    const timeout = this.frameTimeout;
+
+    if ( timeout && this.state === STATE_CONNECTED) {
+      this.frameTimer = setTimeout(() => {
+        this._log('Socket watchdog expired after', timeout, 'closing');
+        this._close();
+        this.dispatchEvent(new CustomEvent(EVENT_FRAME_TIMEOUT));
+      }, timeout);
+    }
+  }
+
+  _error() {
+    this.closingId = (this.socket ? this.socket.sockId : 0);
+    this._log('error');
+  }
+
+  _closed() {
+    console.log(`Socket ${ this.closingId } closed`); // eslint-disable-line no-console
+
+    this.closingId = 0;
+    this.socket = null;
+    clearTimeout(this.reconnectTimer);
+    clearTimeout(this.frameTimer);
+
+    const cbs = this.disconnectCbs;
+
+    while ( cbs.length ) {
+      const fn = cbs.pop();
+
+      if ( fn ) {
+        fn.apply(this);
+      }
+    }
+
+    if ( [STATE_CONNECTED, STATE_CLOSING].includes(this.state) ) {
+      wasConnected = true;
+    }
+
+    if ( !this.disconnectedAt ) {
+      this.disconnectedAt = (new Date()).getTime();
+    }
+
+    if ( !warningShown && !wasConnected ) {
+      this.autoReconnect = false;
+      this.state = STATE_DISCONNECTED;
+
+      const e = new CustomEvent(EVENT_CONNECT_ERROR, { detail: { isSafari } });
+
+      this.dispatchEvent(e);
+      warningShown = true;
+    } else if ( this.autoReconnect ) {
+      this.state = STATE_RECONNECTING;
+      this.tries++;
+      const delay = Math.max(1000, Math.min(1000 * this.tries, 30000));
+
+      this.reconnectTimer = setTimeout(() => {
+        this.connect();
+      }, delay);
+    } else {
+      this.state = STATE_DISCONNECTED;
+    }
+
+    if ( this.state === STATE_DISCONNECTED ) {
+      this.dispatchEvent(new CustomEvent(EVENT_DISCONNECTED));
+    } else if ( this.state === STATE_RECONNECTING ) {
+      this.dispatchEvent(new CustomEvent(EVENT_CONNECTING));
+    }
+  }
+
+  _log(...args) {
+    args.unshift('Socket');
+
+    args.push(`(state=${ this.state }, id=${ this.socket ? this.socket.sockId : 0 })`);
+
+    console.log(args.join(' ')); // eslint-disable-line no-console
+  }
+}

package/utils/sort.js

@@ -0,0 +1,225 @@
+import { get } from './object';
+import { strPad } from './string';
+
+// Based on https://github.com/emberjs/ember.js/blob/master/packages/@ember/-internals/runtime/lib/type-of.js
+// and      https://github.com/emberjs/ember.js/blob/master/packages/@ember/-internals/runtime/lib/mixins/array.js
+/*
+Copyright (c) 2019 Yehuda Katz, Tom Dale and Ember.js contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+// ........................................
+// TYPING & ARRAY MESSAGING
+//
+const TYPE_MAP = {
+  '[object Boolean]':  'boolean',
+  '[object Number]':   'number',
+  '[object String]':   'string',
+  '[object Function]': 'function',
+  '[object Array]':    'array',
+  '[object Date]':     'date',
+  '[object RegExp]':   'regexp',
+  '[object Object]':   'object',
+  '[object FileList]': 'filelist',
+};
+
+const { toString } = Object.prototype;
+
+/**
+  Returns a consistent type for the passed object.
+
+  Use this instead of the built-in `typeof` to get the type of an item.
+  It will return the same result across all browsers and includes a bit
+  more detail. Here is what will be returned:
+
+      | Return Value  | Meaning                                              |
+      |---------------|------------------------------------------------------|
+      | 'string'      | String primitive or String object.                   |
+      | 'number'      | Number primitive or Number object.                   |
+      | 'boolean'     | Boolean primitive or Boolean object.                 |
+      | 'null'        | Null value                                           |
+      | 'undefined'   | Undefined value                                      |
+      | 'function'    | A function                                           |
+      | 'array'       | An instance of Array                                 |
+      | 'regexp'      | An instance of RegExp                                |
+      | 'date'        | An instance of Date                                  |
+      | 'filelist'    | An instance of FileList                              |
+      | 'error'       | An instance of the Error object                      |
+      | 'object'      | A JavaScript object                                  |
+
+  Examples:
+
+  import { typeOf } from '@shell/utils/type-of';
+
+  typeOf();                       // 'undefined'
+  typeOf(null);                   // 'null'
+  typeOf(undefined);              // 'undefined'
+  typeOf('michael');              // 'string'
+  typeOf(new String('michael'));  // 'string'
+  typeOf(101);                    // 'number'
+  typeOf(new Number(101));        // 'number'
+  typeOf(true);                   // 'boolean'
+  typeOf(new Boolean(true));      // 'boolean'
+  typeOf(A);                      // 'function'
+  typeOf([1, 2, 90]);             // 'array'
+  typeOf(/abc/);                  // 'regexp'
+  typeOf(new Date());             // 'date'
+  typeOf(event.target.files);     // 'filelist'
+  typeOf(new Error('teamocil'));  // 'error'
+
+  // 'normal' JavaScript object
+  typeOf({ a: 'b' });             // 'object'
+*/
+export function typeOf(item) {
+  if (item === null) {
+    return 'null';
+  }
+  if (item === undefined) {
+    return 'undefined';
+  }
+  let ret = TYPE_MAP[toString.call(item)] || 'object';
+
+  if (ret === 'object') {
+    if (item instanceof Error) {
+      ret = 'error';
+    } else if (item instanceof Date) {
+      ret = 'date';
+    }
+  }
+
+  return ret;
+}
+
+export function spaceship(a, b) {
+  const diff = a - b;
+
+  return (diff > 0) - (diff < 0);
+}
+
+const TYPE_ORDER = {
+  undefined: 0,
+  null:      1,
+  boolean:   2,
+  number:    3,
+  string:    4,
+  array:     5,
+  object:    6,
+  instance:  7,
+  function:  8,
+  class:     9,
+  date:      10,
+};
+
+export function compare(a, b) {
+  const typeA = typeOf(a);
+  const typeB = typeOf(b);
+
+  const res = spaceship(TYPE_ORDER[typeA], TYPE_ORDER[typeB]);
+
+  if ( res ) {
+    return res;
+  }
+
+  switch (typeA) {
+  case 'boolean':
+  case 'number':
+    return spaceship(a, b);
+
+  case 'string':
+    return spaceship(a.localeCompare(b), 0);
+
+  case 'array': {
+    const aLen = a.length;
+    const bLen = b.length;
+    const len = Math.min(aLen, bLen);
+
+    for (let i = 0; i < len; i++) {
+      const r = compare(a[i], b[i]);
+
+      if (r !== 0) {
+        return r;
+      }
+    }
+
+    // all elements are equal now
+    // shorter array should be ordered first
+    return spaceship(aLen, bLen);
+  }
+  case 'date':
+    return spaceship(a.getTime(), b.getTime());
+  }
+
+  return 0;
+}
+
+export function parseField(str) {
+  const parts = str.split(/:/);
+
+  if ( parts.length === 2 && parts[1] === 'desc' ) {
+    return { field: parts[0], reverse: true };
+  } else {
+    return { field: str, reverse: false };
+  }
+}
+
+export function sortBy(ary, keys, desc) {
+  if ( !Array.isArray(keys) ) {
+    keys = [keys];
+  }
+
+  return ary.slice().sort((objA, objB) => {
+    for ( let i = 0 ; i < keys.length ; i++ ) {
+      const parsed = parseField(keys[i]);
+      const a = get(objA, parsed.field);
+      const b = get(objB, parsed.field);
+      let res = compare(a, b);
+
+      if ( res ) {
+        if ( desc ) {
+          res *= -1;
+        }
+
+        if ( parsed.reverse ) {
+          res *= -1;
+        }
+
+        return res;
+      }
+    }
+
+    return 0;
+  });
+}
+
+// Turn foo1-bar2 into foo0000000001-bar0000000002 so that the numbers sort numerically
+const splitRegex = /([^\d]+)/;
+const notNumericRegex = /^[0-9]+$/;
+
+export function sortableNumericSuffix(str) {
+  if ( typeof str !== 'string' ) {
+    return str;
+  }
+
+  return str.split(splitRegex).map(x => x.match(notNumericRegex) ? strPad(x, 10, '0') : x).join('').trim();
+}
+
+export function isNumeric(num) {
+  return !!`${ num }`.match(notNumericRegex);
+}

package/utils/stream.js

@@ -0,0 +1,49 @@
+export function streamJson(url, opt, onData) {
+  opt = opt || {};
+  opt.method = opt.method || 'get';
+  opt.headers = opt.headers || {};
+  opt.headers.accept = 'application/jsonl';
+
+  const decoder = new TextDecoder();
+  let buf = '';
+
+  return fetch(url, opt)
+    .then((res) => {
+      if ( res.status >= 400 ) {
+        // eslint-disable-next-line no-console
+        console.error('Error Streaming', res);
+
+        const out = { message: 'Error Streaming' };
+
+        out.response = res;
+
+        return Promise.reject(out);
+      } else {
+        return res.body.getReader();
+      }
+    }).then((reader) => {
+      return reader.read().then(function process({ value, done }) {
+        if (done) {
+          onData(JSON.parse(buf));
+
+          return;
+        }
+
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split(/[\r\n](?=.)/);
+
+        buf = lines.pop();
+        lines.map(JSON.parse).forEach(onData);
+
+        return reader.read().then(process);
+      });
+    });
+}
+
+export function streamingSupported() {
+  const supported = typeof TextDecoder !== 'undefined';
+
+  // console.log('Streaming Supported: ', supported);
+
+  return supported;
+}