@rancher/shell 0.1.0

package/utils/create-yaml.js

@@ -0,0 +1,359 @@
+import { indent as _indent } from '@shell/utils/string';
+import { addObject, findBy, removeObject, removeObjects } from '@shell/utils/array';
+import jsyaml from 'js-yaml';
+import { cleanUp } from '@shell/utils/object';
+
+export const SIMPLE_TYPES = [
+  'string',
+  'multiline',
+  'masked',
+  'password',
+  'float',
+  'int',
+  'date',
+  'blob',
+  'boolean',
+  'version'
+];
+
+const ALWAYS_ADD = [
+  'apiVersion',
+  'kind',
+  'metadata',
+  'metadata.name',
+  'spec',
+  'spec.selector',
+  'spec.selector.matchLabels',
+  'spec.template',
+  'spec.template.metadata',
+  'spec.template.metadata.labels',
+  'spec.template.spec.containers.name',
+  'spec.template.spec.containers.image',
+];
+
+export const NEVER_ADD = [
+  'metadata.clusterName',
+  'metadata.clusterName',
+  'metadata.creationTimestamp',
+  'metadata.deletionGracePeriodSeconds',
+  'metadata.deletionTimestamp',
+  'metadata.finalizers',
+  'metadata.generateName',
+  'metadata.generation',
+  'metadata.initializers',
+  'metadata.managedFields',
+  'metadata.ownerReferences',
+  'metadata.resourceVersion',
+  'metadata.relationships',
+  'metadata.selfLink',
+  'metadata.uid',
+  // CRD -> Schema describes the schema used for validation, pruning, and defaulting of this version of the custom resource. If we allow processing we fall into inf loop on openAPIV3Schema.allOf which contains a cyclical ref of allOf props.
+  'spec.versions.schema',
+  'status',
+  'stringData',
+];
+
+export const ACTIVELY_REMOVE = [
+  'metadata.managedFields',
+  'metadata.relationships',
+  'metadata.state',
+  'status',
+  'links',
+  'type',
+  'id'
+];
+
+const INDENT = 2;
+
+export function createYaml(schemas, type, data, processAlwaysAdd = true, depth = 0, path = '', rootType = null) {
+  const schema = findBy(schemas, 'id', type);
+
+  if ( !rootType ) {
+    rootType = type;
+  }
+
+  if ( !schema ) {
+    return `Error loading schema for ${ type }`;
+  }
+
+  data = data || {};
+
+  if ( depth === 0 ) {
+    const attr = schema.attributes || {};
+
+    // Default to data.apiVersion/kind to accommodate spoofed types that aggregate multiple types
+    data.apiVersion = (attr.group ? `${ attr.group }/${ attr.version }` : attr.version) || data.apiVersion;
+    data.kind = attr.kind || data.kind;
+  }
+
+  const regularFields = [];
+
+  if (processAlwaysAdd) {
+    // Add all the parents of each key so that spec.template.foo.blah
+    // causes 'spec', 'template' and 'foo' keys to be created
+    const always = ALWAYS_ADD.slice();
+
+    for ( let i = always.length - 1 ; i >= 0 ; i-- ) {
+      let entry = always[i].split(/\./);
+
+      while ( entry.length ) {
+        addObject(always, entry.join('.'));
+        entry = entry.slice(0, -1);
+      }
+    }
+
+    // Mark always fields as regular so they're not commented out
+    for ( const entry of always ) {
+      const parts = entry.split(/\./);
+      const key = parts[parts.length - 1];
+      const prefix = parts.slice(0, -1).join('.');
+
+      if ( prefix === path && schema.resourceFields && schema.resourceFields[key] ) {
+        addObject(regularFields, key);
+      }
+    }
+  }
+
+  // Mark any fields that are passed in as data as regular so they're not commented out
+  const commentFields = Object.keys(schema.resourceFields || {});
+
+  commentFields.forEach((key) => {
+    if ( typeof data[key] !== 'undefined' || (depth === 0 && key === '_type') ) {
+      addObject(regularFields, key);
+    }
+  });
+
+  for ( const key in data ) {
+    if ( typeof data[key] !== 'undefined' ) {
+      addObject(regularFields, key);
+    }
+  }
+
+  for ( const entry of ACTIVELY_REMOVE ) {
+    const parts = entry.split(/\./);
+    const key = parts[parts.length - 1];
+    const prefix = parts.slice(0, -1).join('.');
+
+    if ( prefix === path) {
+      removeObject(regularFields, key);
+    }
+  }
+
+  for ( const entry of NEVER_ADD ) {
+    const parts = entry.split(/\./);
+    const key = parts[parts.length - 1];
+    const prefix = parts.slice(0, -1).join('.');
+
+    if ( prefix === path && schema.resourceFields && schema.resourceFields[key] ) {
+      removeObject(commentFields, key);
+    }
+  }
+
+  removeObjects(commentFields, regularFields);
+
+  const regular = regularFields.map(k => stringifyField(k));
+  const comments = commentFields.map((k) => {
+    // Don't add a namespace comment for types that aren't namespaced.
+    if ( path === 'metadata' && k === 'namespace' ) {
+      const rootSchema = findBy(schemas, 'id', rootType);
+
+      if ( rootSchema && !rootSchema.attributes?.namespaced ) {
+        return null;
+      }
+    }
+
+    return comment(stringifyField(k));
+  });
+
+  const out = [...regular, ...comments]
+    .filter(x => x !== null)
+    .join('\n')
+    .trim();
+
+  return out;
+
+  // ---------------
+
+  function stringifyField(key) {
+    const field = schema.resourceFields?.[key];
+    let out = `${ key }:`;
+
+    // '_type' in steve maps to kubernetes 'type' field; show 'type' field in yaml
+    if (key === '_type') {
+      out = 'type:';
+    }
+
+    if ( !field ) {
+      if (data[key]) {
+        try {
+          const cleaned = cleanUp(data);
+          const parsedData = jsyaml.dump(cleaned[key]);
+
+          if ( typeof data[key] === 'object' || Array.isArray(data[key]) ) {
+            out += `\n${ indent(parsedData.trim()) }`;
+          } else {
+            out += ` ${ parsedData.trim() }`;
+          }
+
+          return out;
+        } catch (e) {
+          console.error(`Error: Unable to parse map data for yaml key: ${ key }`, e); // eslint-disable-line no-console
+        }
+      }
+
+      return null;
+    }
+
+    const type = typeMunge(field.type);
+    const mapOf = typeRef('map', type);
+    const arrayOf = typeRef('array', type);
+    const referenceTo = typeRef('reference', type);
+
+    if ( mapOf ) {
+      if (data[key]) {
+        try {
+          const cleaned = cleanUp(data);
+          const parsedData = jsyaml.dump(cleaned[key]);
+
+          out += `\n${ indent(parsedData.trim()) }`;
+        } catch (e) {
+          console.error(`Error: Unable to parse map data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
+        }
+      }
+
+      if ( SIMPLE_TYPES.includes(mapOf) ) {
+        out += `\n#  key: ${ mapOf }`;
+      } else {
+        const chunk = createYaml(schemas, mapOf, null, processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType);
+        let indented = indent(chunk, 2);
+
+        indented = indented.replace(/^(#)?\s\s\s\s/, '$1');
+
+        out += `\n  ${ indented }`;
+      }
+
+      return out;
+    }
+
+    if ( arrayOf ) {
+      if (data[key]) {
+        try {
+          const cleaned = cleanUp(data);
+
+          if ( cleaned?.[key] ) {
+            const parsedData = jsyaml.dump(cleaned[key]);
+
+            out += `\n${ indent(parsedData.trim()) }`;
+          }
+        } catch (e) {
+          console.error(`Error: Unale to parse array data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
+        }
+      }
+
+      if ( SIMPLE_TYPES.includes(arrayOf) ) {
+        out += `\n#  - ${ arrayOf }`;
+      } else {
+        const chunk = createYaml(schemas, arrayOf, null, false, depth + 1, (path ? `${ path }.${ key }` : key), rootType);
+        let indented = indent(chunk, 2);
+
+        indented = indented.replace(/^(#)?\s*\s\s([^\s])/, '$1  - $2');
+
+        out += `\n${ indented }`;
+      }
+
+      return out;
+    }
+
+    if ( referenceTo ) {
+      out += ` #${ referenceTo }`;
+
+      return out;
+    }
+
+    if ( SIMPLE_TYPES.includes(type) ) {
+      if (key === '_type' && typeof data[key] === 'undefined' && typeof data['type'] !== 'undefined') {
+        out += ` ${ serializeSimpleValue(data['type']) }`;
+      } else if ( typeof data[key] === 'undefined' ) {
+        out += ` #${ serializeSimpleValue(type) }`;
+      } else {
+        out += ` ${ serializeSimpleValue(data[key]) }`;
+      }
+
+      return out;
+    }
+
+    /**
+     * .spec is the type used for the Logging chart Output and ClusterOutput resource spec.
+     * Without this Output and ClusterOutput specs are empty.
+     */
+    if ( type === 'json' || type === '.spec') {
+      try {
+        const parsedData = jsyaml.dump(data[key]);
+
+        if (parsedData) {
+          out += `\n${ indent(parsedData.trim()) }`;
+        } else {
+          out += ` #${ type }`;
+        }
+
+        return out;
+      } catch (e) {
+      }
+    }
+
+    const subDef = findBy(schemas, 'id', type);
+
+    if ( subDef ) {
+      const chunk = createYaml(schemas, type, data[key], processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType);
+
+      out += `\n${ indent(chunk) }`;
+    } else {
+      out += ` #${ type }`;
+    }
+
+    return out;
+  }
+}
+
+function comment(lines) {
+  return (lines || '').split('\n').map(x => `#${ x.replace(/#/g, '') }`).join('\n');
+}
+
+function indent(lines, depth = 1) {
+  return _indent(lines, depth * INDENT, ' ', /^#/);
+}
+
+function serializeSimpleValue(data) {
+  return jsyaml.dump(data).trim();
+}
+
+export function typeRef(type, str) {
+  const re = new RegExp(`^${ type }\\[(.*)\\]$`);
+  const match = str.match(re);
+
+  if ( match ) {
+    return typeMunge(match[1]);
+  }
+}
+
+export function typeMunge(type) {
+  if ( type === 'integer' ) {
+    return 'int';
+  }
+
+  if ( type === 'io.k8s.apimachinery.pkg.api.resource.Quantity' ) {
+    return 'string';
+  }
+
+  return type;
+}
+
+export function saferDump(obj) {
+  const out = jsyaml.dump(obj || {});
+
+  if ( out === '{}\n' ) {
+    return '';
+  }
+
+  return out;
+}

package/utils/crypto/LICENSE.txt

@@ -0,0 +1,15 @@
+Extracted portions of https://github.com/aws/aws-sdk-js
+
+Copyright 2012-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/utils/crypto/browserHashUtils.js

@@ -0,0 +1,33 @@
+import { Buffer } from 'buffer';
+
+/**
+ * @api private
+ */
+export function isEmptyData(data) {
+  if (typeof data === 'string') {
+    return data.length === 0;
+  }
+
+  return data.byteLength === 0;
+}
+
+/**
+ * @api private
+ */
+export function convertToBuffer(data) {
+  if (typeof data === 'string') {
+    // eslint-disable-next-line node/no-deprecated-api, unicorn/no-new-buffer
+    data = new Buffer(data, 'utf8');
+  }
+
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+  }
+
+  return new Uint8Array(data);
+}
+
+export default {
+  isEmptyData,
+  convertToBuffer,
+};

package/utils/crypto/browserMd5.js

@@ -0,0 +1,183 @@
+import { Buffer } from 'buffer';
+import { isEmptyData, convertToBuffer } from './browserHashUtils';
+
+const BLOCK_SIZE = 64;
+
+const DIGEST_LENGTH = 16;
+
+/**
+ * @api private
+ */
+function Md5() {
+  this.state = [
+    0x67452301,
+    0xEFCDAB89,
+    0x98BADCFE,
+    0x10325476,
+  ];
+  this.buffer = new DataView(new ArrayBuffer(BLOCK_SIZE));
+  this.bufferLength = 0;
+  this.bytesHashed = 0;
+  this.finished = false;
+}
+
+/**
+ * @api private
+ */
+export default Md5;
+
+Md5.BLOCK_SIZE = BLOCK_SIZE;
+
+Md5.prototype.update = function(sourceData) {
+  if (isEmptyData(sourceData)) {
+    return this;
+  } else if (this.finished) {
+    throw new Error('Attempted to update an already finished hash.');
+  }
+
+  const data = convertToBuffer(sourceData);
+  let position = 0;
+  let byteLength = data.byteLength;
+
+  this.bytesHashed += byteLength;
+  while (byteLength > 0) {
+    this.buffer.setUint8(this.bufferLength++, data[position++]);
+    byteLength--;
+    if (this.bufferLength === BLOCK_SIZE) {
+      this.hashBuffer();
+      this.bufferLength = 0;
+    }
+  }
+
+  return this;
+};
+
+Md5.prototype.digest = function(encoding) {
+  if (!this.finished) {
+    const _a = this; const buffer = _a.buffer; const undecoratedLength = _a.bufferLength; const bytesHashed = _a.bytesHashed;
+    const bitsHashed = bytesHashed * 8;
+
+    buffer.setUint8(this.bufferLength++, 128);
+    // Ensure the final block has enough room for the hashed length
+    if (undecoratedLength % BLOCK_SIZE >= BLOCK_SIZE - 8) {
+      for (let i = this.bufferLength; i < BLOCK_SIZE; i++) {
+        buffer.setUint8(i, 0);
+      }
+      this.hashBuffer();
+      this.bufferLength = 0;
+    }
+    for (let i = this.bufferLength; i < BLOCK_SIZE - 8; i++) {
+      buffer.setUint8(i, 0);
+    }
+    buffer.setUint32(BLOCK_SIZE - 8, bitsHashed >>> 0, true);
+    buffer.setUint32(BLOCK_SIZE - 4, Math.floor(bitsHashed / 0x100000000), true);
+    this.hashBuffer();
+    this.finished = true;
+  }
+  const out = new DataView(new ArrayBuffer(DIGEST_LENGTH));
+
+  for (let i = 0; i < 4; i++) {
+    out.setUint32(i * 4, this.state[i], true);
+  }
+
+  // eslint-disable-next-line node/no-deprecated-api, unicorn/no-new-buffer
+  const buff = new Buffer(out.buffer, out.byteOffset, out.byteLength);
+
+  return encoding ? buff.toString(encoding) : buff;
+};
+
+Md5.prototype.hashBuffer = function() {
+  const _a = this; const buffer = _a.buffer; const state = _a.state;
+  let a = state[0]; let b = state[1]; let c = state[2]; let d = state[3];
+
+  a = ff(a, b, c, d, buffer.getUint32(0, true), 7, 0xD76AA478);
+  d = ff(d, a, b, c, buffer.getUint32(4, true), 12, 0xE8C7B756);
+  c = ff(c, d, a, b, buffer.getUint32(8, true), 17, 0x242070DB);
+  b = ff(b, c, d, a, buffer.getUint32(12, true), 22, 0xC1BDCEEE);
+  a = ff(a, b, c, d, buffer.getUint32(16, true), 7, 0xF57C0FAF);
+  d = ff(d, a, b, c, buffer.getUint32(20, true), 12, 0x4787C62A);
+  c = ff(c, d, a, b, buffer.getUint32(24, true), 17, 0xA8304613);
+  b = ff(b, c, d, a, buffer.getUint32(28, true), 22, 0xFD469501);
+  a = ff(a, b, c, d, buffer.getUint32(32, true), 7, 0x698098D8);
+  d = ff(d, a, b, c, buffer.getUint32(36, true), 12, 0x8B44F7AF);
+  c = ff(c, d, a, b, buffer.getUint32(40, true), 17, 0xFFFF5BB1);
+  b = ff(b, c, d, a, buffer.getUint32(44, true), 22, 0x895CD7BE);
+  a = ff(a, b, c, d, buffer.getUint32(48, true), 7, 0x6B901122);
+  d = ff(d, a, b, c, buffer.getUint32(52, true), 12, 0xFD987193);
+  c = ff(c, d, a, b, buffer.getUint32(56, true), 17, 0xA679438E);
+  b = ff(b, c, d, a, buffer.getUint32(60, true), 22, 0x49B40821);
+  a = gg(a, b, c, d, buffer.getUint32(4, true), 5, 0xF61E2562);
+  d = gg(d, a, b, c, buffer.getUint32(24, true), 9, 0xC040B340);
+  c = gg(c, d, a, b, buffer.getUint32(44, true), 14, 0x265E5A51);
+  b = gg(b, c, d, a, buffer.getUint32(0, true), 20, 0xE9B6C7AA);
+  a = gg(a, b, c, d, buffer.getUint32(20, true), 5, 0xD62F105D);
+  d = gg(d, a, b, c, buffer.getUint32(40, true), 9, 0x02441453);
+  c = gg(c, d, a, b, buffer.getUint32(60, true), 14, 0xD8A1E681);
+  b = gg(b, c, d, a, buffer.getUint32(16, true), 20, 0xE7D3FBC8);
+  a = gg(a, b, c, d, buffer.getUint32(36, true), 5, 0x21E1CDE6);
+  d = gg(d, a, b, c, buffer.getUint32(56, true), 9, 0xC33707D6);
+  c = gg(c, d, a, b, buffer.getUint32(12, true), 14, 0xF4D50D87);
+  b = gg(b, c, d, a, buffer.getUint32(32, true), 20, 0x455A14ED);
+  a = gg(a, b, c, d, buffer.getUint32(52, true), 5, 0xA9E3E905);
+  d = gg(d, a, b, c, buffer.getUint32(8, true), 9, 0xFCEFA3F8);
+  c = gg(c, d, a, b, buffer.getUint32(28, true), 14, 0x676F02D9);
+  b = gg(b, c, d, a, buffer.getUint32(48, true), 20, 0x8D2A4C8A);
+  a = hh(a, b, c, d, buffer.getUint32(20, true), 4, 0xFFFA3942);
+  d = hh(d, a, b, c, buffer.getUint32(32, true), 11, 0x8771F681);
+  c = hh(c, d, a, b, buffer.getUint32(44, true), 16, 0x6D9D6122);
+  b = hh(b, c, d, a, buffer.getUint32(56, true), 23, 0xFDE5380C);
+  a = hh(a, b, c, d, buffer.getUint32(4, true), 4, 0xA4BEEA44);
+  d = hh(d, a, b, c, buffer.getUint32(16, true), 11, 0x4BDECFA9);
+  c = hh(c, d, a, b, buffer.getUint32(28, true), 16, 0xF6BB4B60);
+  b = hh(b, c, d, a, buffer.getUint32(40, true), 23, 0xBEBFBC70);
+  a = hh(a, b, c, d, buffer.getUint32(52, true), 4, 0x289B7EC6);
+  d = hh(d, a, b, c, buffer.getUint32(0, true), 11, 0xEAA127FA);
+  c = hh(c, d, a, b, buffer.getUint32(12, true), 16, 0xD4EF3085);
+  b = hh(b, c, d, a, buffer.getUint32(24, true), 23, 0x04881D05);
+  a = hh(a, b, c, d, buffer.getUint32(36, true), 4, 0xD9D4D039);
+  d = hh(d, a, b, c, buffer.getUint32(48, true), 11, 0xE6DB99E5);
+  c = hh(c, d, a, b, buffer.getUint32(60, true), 16, 0x1FA27CF8);
+  b = hh(b, c, d, a, buffer.getUint32(8, true), 23, 0xC4AC5665);
+  a = ii(a, b, c, d, buffer.getUint32(0, true), 6, 0xF4292244);
+  d = ii(d, a, b, c, buffer.getUint32(28, true), 10, 0x432AFF97);
+  c = ii(c, d, a, b, buffer.getUint32(56, true), 15, 0xAB9423A7);
+  b = ii(b, c, d, a, buffer.getUint32(20, true), 21, 0xFC93A039);
+  a = ii(a, b, c, d, buffer.getUint32(48, true), 6, 0x655B59C3);
+  d = ii(d, a, b, c, buffer.getUint32(12, true), 10, 0x8F0CCC92);
+  c = ii(c, d, a, b, buffer.getUint32(40, true), 15, 0xFFEFF47D);
+  b = ii(b, c, d, a, buffer.getUint32(4, true), 21, 0x85845DD1);
+  a = ii(a, b, c, d, buffer.getUint32(32, true), 6, 0x6FA87E4F);
+  d = ii(d, a, b, c, buffer.getUint32(60, true), 10, 0xFE2CE6E0);
+  c = ii(c, d, a, b, buffer.getUint32(24, true), 15, 0xA3014314);
+  b = ii(b, c, d, a, buffer.getUint32(52, true), 21, 0x4E0811A1);
+  a = ii(a, b, c, d, buffer.getUint32(16, true), 6, 0xF7537E82);
+  d = ii(d, a, b, c, buffer.getUint32(44, true), 10, 0xBD3AF235);
+  c = ii(c, d, a, b, buffer.getUint32(8, true), 15, 0x2AD7D2BB);
+  b = ii(b, c, d, a, buffer.getUint32(36, true), 21, 0xEB86D391);
+  state[0] = (a + state[0]) & 0xFFFFFFFF;
+  state[1] = (b + state[1]) & 0xFFFFFFFF;
+  state[2] = (c + state[2]) & 0xFFFFFFFF;
+  state[3] = (d + state[3]) & 0xFFFFFFFF;
+};
+
+function cmn(q, a, b, x, s, t) {
+  a = (((a + q) & 0xFFFFFFFF) + ((x + t) & 0xFFFFFFFF)) & 0xFFFFFFFF;
+
+  return (((a << s) | (a >>> (32 - s))) + b) & 0xFFFFFFFF;
+}
+
+function ff(a, b, c, d, x, s, t) {
+  return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+}
+
+function gg(a, b, c, d, x, s, t) {
+  return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+}
+
+function hh(a, b, c, d, x, s, t) {
+  return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function ii(a, b, c, d, x, s, t) {
+  return cmn(c ^ (b | (~d)), a, b, x, s, t);
+}