@rancher/shell 0.1.0 → 0.1.1

package/utils/validators/formRules/index.ts

@@ -0,0 +1,447 @@
+import { RBAC } from '@shell/config/types';
+import { HCI } from '@shell/config/labels-annotations';
+import isEmpty from 'lodash/isEmpty';
+import has from 'lodash/has';
+// import uniq from 'lodash/uniq';
+import cronstrue from 'cronstrue';
+
+// import uniq from 'lodash/uniq';
+export type Validator = (val: any, arg?: any) => undefined | string;
+
+export type ValidatorFactory = (arg1: any, arg2?: any) => Validator
+
+type ServicePort = {
+  name?: string,
+  nodePort?: string | number,
+  port?: string | number,
+  targetPort?: string | number,
+  idx: number
+}
+
+export class Port {
+  empty: boolean;
+  int: number;
+  string: string;
+  isNumber: boolean;
+  isInt: boolean;
+  constructor(port: number | string | undefined) {
+    this.string = String(port);
+    this.int = parseInt(this.string, 10);
+    this.empty = (!port && this.int !== 0);
+    this.isNumber = !isNaN(this.int) && !this.string.includes('e'); // leaving out the exponent edge case to keep the logic simple and because port numbers aren't that big...
+    this.isInt = this.isNumber && !this.string.includes('.');
+  }
+}
+
+const httpsKeys = [
+  'server-url'
+];
+
+const runValidators = (val: any, validators: Validator[]) => {
+  for (const validator of validators) {
+    const message = validator(val);
+
+    if (message) {
+      return message;
+    }
+  }
+};
+
+// "t" is the function name we use for getting a translated string
+export default function(t: (key: string, options?: any) => string, opt: {displayKey?: string} = {}) {
+  const { displayKey = 'Value' } = opt;
+
+  // utility validators these validators only get used by other validators
+  const startDot: ValidatorFactory = (label: string): Validator => (val: string) => val?.slice(0, 1) === '.' ? t(`validation.dns.${ label }.startDot`, { key: displayKey }) : undefined;
+
+  const endDot = (label: string): Validator => (val: string) => val?.slice(-1) === '.' ? t(`validation.dns.${ label }.endDot`, { key: displayKey }) : undefined;
+
+  const startNumber: ValidatorFactory = (label: string): Validator => (val: string) => val?.slice(0, 1)?.match(/[0-9]/) ? t(`validation.dns.${ label }.startNumber`, { key: displayKey }) : undefined;
+
+  const startHyphen: ValidatorFactory = (label: string): Validator => (val: string) => val?.slice(0, 1) === '-' ? t(`validation.dns.${ label }.startHyphen`, { key: displayKey }) : undefined;
+
+  const endHyphen: ValidatorFactory = (label: string): Validator => (val: string) => val?.slice(-1) === '-' ? t(`validation.dns.${ label }.endHyphen`, { key: displayKey }) : undefined;
+
+  const requiredInt: Validator = (val: string) => isNaN(parseInt(val, 10)) ? t('validation.number.requiredInt', { key: displayKey }) : undefined;
+
+  const portNumber: Validator = (val: string) => parseInt(val, 10) < 1 || parseInt(val, 10) > 65535 ? t('validation.number.between', {
+    key: displayKey, min: '1', max: '65535'
+  }) : undefined;
+
+  const dnsChars: Validator = (val: string) => {
+    const matchedChars = val?.match(/[^${'A-Za-z0-9-'}]/g);
+
+    if (matchedChars) {
+      return t('validation.chars', {
+        key: displayKey, count: matchedChars.length, chars: matchedChars.map(char => char === ' ' ? 'Space' : `"${ char }"`).join(', ')
+      });
+    }
+
+    return undefined;
+  };
+
+  // the weird edge case here deals with internationalized domain names which are prepended with 'xn--'
+  // https://datatracker.ietf.org/doc/html/rfc5891#section-4.2.3.1
+  const dnsDoubleDash: Validator = (val: string) => (val?.substr(2, 2) === '--' && val?.substr(0, 2) !== 'xn') ? t(`validation.dns.doubleHyphen`, { key: displayKey }) : undefined;
+
+  const dnsIanaServiceNameDoubleDash: Validator = (val: string) => (val?.substr(2, 2) === '--' && val?.substr(0, 2) !== 'xn') ? t(`validation.dns.doubleHyphen`, { key: displayKey }) : undefined;
+
+  const dnsEmpty: ValidatorFactory = (label: string): Validator => (val = '') => val.length === 0 ? t(`validation.dns.${ label }.emptyLabel`, { key: displayKey, min: 1 }) : undefined;
+
+  const dnsTooLong: ValidatorFactory = (label: string, length = 63): Validator => (val = '') => val.length > length ? t(`validation.dns.${ label }.tooLongLabel`, { key: displayKey, max: length }) : undefined;
+
+  // eslint-disable-next-line no-unused-vars
+  const hostnameEmpty: Validator = (val = '') => val.length === 0 ? t('validation.dns.hostname.empty', { key: displayKey }) : undefined;
+
+  const hostnameTooLong: Validator = (val = '') => val.length > 253 ? t('validation.dns.hostname.tooLong', { key: displayKey, max: 253 }) : undefined;
+
+  const absolutePath: Validator = (val = '') => val[0] !== '/' && val.length > 0 ? t('validation.path', { key: displayKey }) : undefined;
+
+  const required: Validator = (val: any) => !val && val !== false ? t('validation.required', { key: displayKey }) : undefined;
+
+  const noUpperCase: Validator = (val = '') => val.toLowerCase() !== val ? t('validation.noUpperCase', { key: displayKey }) : undefined;
+
+  const cronSchedule: Validator = (val: string) => {
+    try {
+      cronstrue.toString(val);
+    } catch (e) {
+      return t('validation.invalidCron');
+    }
+  };
+
+  const isHttps: ValidatorFactory = (key: string) => {
+    const isHttps: Validator = (val: string) => httpsKeys.includes(key) && !val.toLowerCase().startsWith('https://') ? t('validation.setting.serverUrl.https') : undefined;
+
+    return isHttps;
+  };
+
+  const interval: Validator = (val: string) => !/^\d+[hms]$/.test(val) ? t('validation.monitoring.route.interval', { key: displayKey }) : undefined;
+
+  const containerImage: Validator = (val: any) => !val?.image ? t('workload.validation.containerImage', { name: val.name }) : undefined;
+
+  const containerImages: Validator = (val: any | [any]) => {
+    const containers = val.jobTemplate ? val?.jobTemplate?.spec?.template?.spec?.containers : val?.template?.spec?.containers;
+
+    if (!containers || !containers.length) {
+      return t('validation.required', { key: t('workload.container.titles.containers') });
+    }
+
+    // making sure each container has an imagename
+    return containers.map((container: any) => containerImage(container)).find((containerError: string) => containerError);
+  };
+
+  const dnsLabel: Validator = (val: string) => {
+    const validators = [
+      dnsChars,
+      startHyphen('label'),
+      endHyphen('label'),
+      dnsDoubleDash,
+      // dnsEmpty('label'), // questionable as to if this is needed if the field is also required...
+      dnsTooLong('label')
+    ];
+
+    return runValidators(val, validators);
+  };
+
+  const dnsLabelIanaServiceName: Validator = (val: string) => {
+    const validators = [
+      dnsChars,
+      startHyphen('label'),
+      endHyphen('label'),
+      dnsIanaServiceNameDoubleDash,
+      dnsEmpty('label'), // questionable as to if this is needed if the field is also required...
+      dnsTooLong('label', 15)
+    ];
+
+    return runValidators(val, validators);
+  };
+
+  const dnsLabelRestricted: Validator = (val: string) => {
+    const validators = [
+      dnsChars,
+      startNumber('label'),
+      startHyphen('label'),
+      endHyphen('label'),
+      dnsDoubleDash,
+      dnsEmpty('label'), // questionable as to if this is needed if the field is also required...
+      dnsTooLong('label')
+    ];
+
+    return runValidators(val, validators);
+  };
+
+  const hostname: Validator = (val: string) => {
+    if (val) {
+      const validators = [
+        startDot('hostname'),
+        hostnameTooLong,
+        endDot('hostname')
+      ];
+
+      const hostNameMessage = runValidators(val, validators);
+
+      if (hostNameMessage) {
+        return hostNameMessage;
+      }
+
+      const labels = val.split('.');
+      const labelValidators = [
+        dnsChars,
+        startHyphen('hostname'),
+        endHyphen('hostname'),
+        dnsDoubleDash,
+        dnsEmpty('hostname'),
+        dnsTooLong('hostname')
+      ];
+
+      for ( let i = 0; i < labels.length; i++ ) {
+        const labelMessage = runValidators(labels[i], labelValidators);
+
+        if (labelMessage) {
+          return labelMessage;
+        }
+      }
+    }
+  };
+
+  const externalName: Validator = (val: string) => {
+    if (isEmpty(val)) {
+      return t('validation.service.externalName.none');
+    } else {
+      return hostname(val);
+    }
+  };
+
+  const testRule = (val: string | undefined) => {
+    return 'This is an error returned by the testRule validator';
+  };
+
+  const ruleGroups: Validator = (val: {groups?: any}) => isEmpty(val?.groups) ? t('validation.prometheusRule.groups.required') : undefined;
+
+  const clusterName: ValidatorFactory = (isRke2: boolean): Validator => (val: string | undefined) => isRke2 && (val || '')?.match(/^(c-.{5}|local)$/i) ? t('validation.cluster.name') : undefined;
+
+  const servicePort = (val: ServicePort) => {
+    const {
+      name,
+      idx
+    } = val;
+
+    const nodePort = new Port(val.nodePort);
+    const listeningPort = new Port(val.port);
+    const targetPort = new Port(val.targetPort);
+
+    if (isEmpty(name)) {
+      return t('validation.service.ports.name.required', { position: idx + 1 });
+    }
+
+    if (!nodePort.empty) {
+      if (!nodePort.isInt) {
+        return t('validation.service.ports.nodePort.requiredInt', { position: idx + 1 });
+      } else if (nodePort.int < 1 || nodePort.int > 65535) {
+        return t('validation.service.ports.nodePort.between', { position: idx + 1 });
+      }
+    }
+
+    if (!listeningPort.empty) {
+      if (!listeningPort.isInt) {
+        return t('validation.service.ports.port.requiredInt', { position: idx + 1 });
+      } else if (listeningPort.int < 1 || listeningPort.int > 65535) {
+        return t('validation.service.ports.port.between', { position: idx + 1 });
+      } else if (listeningPort.string?.includes('.')) {
+        return listeningPort;
+      }
+    } else {
+      return t('validation.service.ports.port.required', { position: idx + 1 });
+    }
+
+    if (!targetPort.empty) {
+      if (!targetPort.isInt) {
+        const ianaServiceNameErrors = dnsLabelIanaServiceName(targetPort.string);
+
+        if (ianaServiceNameErrors) {
+          return ianaServiceNameErrors;
+        }
+      } else if (targetPort.int < 1 || targetPort.int > 65535) {
+        return t('validation.service.ports.targetPort.between', { position: idx + 1 });
+      }
+    } else {
+      return t('validation.service.ports.targetPort.required', { position: idx + 1 });
+    }
+
+    return undefined;
+  };
+
+  const groupIsValid: Validator = (val, readableIndex) => {
+    let returnMessage: string | undefined;
+
+    if (isEmpty(val?.name)) {
+      return t('validation.prometheusRule.groups.valid.name', { index: readableIndex });
+    }
+
+    if (isEmpty(val.rules)) {
+      return t('validation.prometheusRule.groups.valid.singleEntry', { index: readableIndex });
+    } else {
+      val.rules.forEach((rule: any, idx: number) => {
+        const readableRuleIndex = idx + 1;
+
+        if (has(rule, 'alert') && isEmpty(rule?.alert) && !returnMessage) {
+          returnMessage = t('validation.prometheusRule.groups.valid.rule.alertName', { groupIndex: readableIndex, ruleIndex: readableRuleIndex });
+        } else if (has(rule, 'record') && isEmpty(rule?.record)) {
+          returnMessage = t('validation.prometheusRule.groups.valid.rule.recordName', { groupIndex: readableIndex, ruleIndex: readableRuleIndex });
+        }
+
+        if ((has(rule, 'expr') && isEmpty(rule.expr) && !returnMessage) || (!has(rule, 'expr') && !returnMessage)) {
+          returnMessage = t('validation.prometheusRule.groups.valid.rule.expr', { groupIndex: readableIndex, ruleIndex: readableRuleIndex });
+        }
+
+        if (has(rule, 'alert')) {
+          if (
+            (has(rule, 'labels') && isEmpty(rule.labels) && !returnMessage) ||
+            (!has(rule, 'labels') && !returnMessage)
+          ) {
+            returnMessage = t('validation.prometheusRule.groups.valid.rule.labels', { groupIndex: readableIndex, ruleIndex: readableRuleIndex });
+          }
+        }
+      });
+    }
+
+    return returnMessage;
+  };
+
+  const groupsAreValid: Validator = (val) => {
+    const groups = [...val]; // making a new array in the function because I'm gonna mutate it later...
+    let message;
+
+    groups.forEach((group, idx, arr) => {
+      message = groupIsValid(group, idx + 1);
+      if (!!message) {
+        arr.length = idx + 1; // this is a tricksy way of breaking a forEach loop since we just want the first message
+      }
+    });
+
+    return message;
+  };
+
+  const matching: Validator = (val) => {
+    if (isEmpty(val?.match) && isEmpty(val?.['match_re'])) {
+      return t('validation.monitoring.route.match');
+    }
+  };
+
+  const roleTemplateRules: ValidatorFactory = (type): Validator => (val = []) => {
+    if (val.some((rule: any) => isEmpty(rule.verbs))) {
+      return t('validation.roleTemplate.roleTemplateRules.missingVerb');
+    }
+
+    if (type === RBAC.ROLE) {
+      if (val.some((rule: any) => isEmpty(rule.resources))) {
+        return t('validation.roleTemplate.roleTemplateRules.missingResource');
+      }
+
+      if (val.some((rule: any) => isEmpty(rule.apiGroups))) {
+        return t('validation.roleTemplate.roleTemplateRules.missingApiGroup');
+      }
+    } else if (val.some((rule: any) => isEmpty(rule.resources) && isEmpty(rule.nonResourceURLs) && isEmpty(rule.apiGroups))) {
+      return t('validation.roleTemplate.roleTemplateRules.missingOneResource');
+    }
+
+    return undefined;
+  };
+
+  // The existing validator for clusterIp never actually returns an error
+  const clusterIp: Validator = val => undefined;
+
+  const backupTarget: Validator = (val) => {
+    const parseValue = JSON.parse(val);
+    const type = parseValue.type;
+
+    if (!type) {
+      return t('validation.required', { key: 'Type' });
+    }
+
+    if (type === 's3') {
+      if (!parseValue.accessKeyId) {
+        return t('validation.required', { key: 'accessKeyId' });
+      }
+
+      if (!parseValue.secretAccessKey) {
+        return t('validation.required', { key: 'secretAccessKey' });
+      }
+
+      if (!parseValue.bucketRegion) {
+        return t('validation.required', { key: 'bucketRegion' });
+      }
+
+      if (!parseValue.bucketName) {
+        return t('validation.required', { key: 'bucketName' });
+      }
+    }
+
+    return undefined;
+  };
+
+  const imageUrl: Validator = (val) => {
+    const VM_IMAGE_FILE_FORMAT = ['qcow', 'qcow2', 'raw', 'img', 'iso'];
+
+    if (!val || val === '') {
+      return undefined;
+    }
+
+    const urlSlug = val.split('/').pop();
+    const fileExtension = urlSlug.split('.').pop().toLowerCase();
+
+    if (!VM_IMAGE_FILE_FORMAT.includes(fileExtension)) {
+      return t('harvester.validation.image.ruleTip');
+    }
+
+    return undefined;
+  };
+
+  const fileRequired: Validator = (val = {}) => {
+    if (!val[HCI.IMAGE_NAME]) {
+      return t('validation.required', { key: t('harvester.image.fileName') });
+    }
+  };
+
+  const subDomain: Validator = (val) => {
+    const matchedChars = val?.match(/[^a-z0-9.-]/g);
+
+    if (matchedChars) {
+      return t('validation.chars', {
+        key: displayKey, count: matchedChars.length, chars: matchedChars.map((char: string) => char === ' ' ? 'Space' : `"${ char }"`).join(', ')
+      });
+    }
+
+    return runValidators(val, [startHyphen('label'), endHyphen('label'), startDot('label'), endDot('label'), required]);
+  };
+
+  return {
+    noUpperCase,
+    required,
+    requiredInt,
+    portNumber,
+    cronSchedule,
+    isHttps,
+    interval,
+    containerImage,
+    containerImages,
+    ruleGroups,
+    groupsAreValid,
+    matching,
+    clusterName,
+    roleTemplateRules,
+    servicePort,
+    clusterIp,
+    externalName,
+    backupTarget,
+    imageUrl,
+    fileRequired,
+    dnsLabel,
+    dnsLabelIanaServiceName,
+    dnsLabelRestricted,
+    hostname,
+    testRule,
+    subDomain,
+    absolutePath
+  };
+}

package/utils/validators/prometheusrule.js

@@ -9,7 +9,7 @@ export function ruleGroups(spec, getters, errors, validatorArgs) {
   return errors;
 }
 
-export function groupsAreValid(groups, getters, errors, validatorArgs) {
+export function groupsAreValid(groups = [], getters, errors, validatorArgs) {
   groups.forEach((group, groupIndex) => {
     const readableGroupIndex = groupIndex + 1; // oh that ol zero based array index....
 

package/utils/validators/vm.js

@@ -119,15 +119,15 @@ export function vmDisks(spec, getters, errors, validatorArgs, displayKey, value)
     errors.push(getters['i18n/t']('harvester.validation.vm.volume.needImageOrExisting'));
   }
 
-  let hasImageVolumeOrExistingVolume = false;
+  let requiredVolume = false;
 
   _volumes.forEach((V, idx) => {
     const { type, typeValue } = getVolumeType(V, _volumeClaimTemplates);
     const prefix = V.name || idx + 1;
 
-    if (type === SOURCE_TYPE.IMAGE || type === SOURCE_TYPE.ATTACH_VOLUME) { // root image
+    if ([SOURCE_TYPE.IMAGE, SOURCE_TYPE.ATTACH_VOLUME, SOURCE_TYPE.CONTAINER].includes(type)) { // root image
       // const message = getters['i18n/t']('harvester.validation.vm.volume.needImageOrExisting');
-      hasImageVolumeOrExistingVolume = true;
+      requiredVolume = true;
       // errors.push(message);
     }
 
@@ -160,14 +160,14 @@ export function vmDisks(spec, getters, errors, validatorArgs, displayKey, value)
       }
     }
 
-    if (V?.containerDisk && !V.containerDisk.image) {
+    if (type === SOURCE_TYPE.CONTAINER && !V.containerDisk.image) {
       const message = getters['i18n/t']('harvester.validation.vm.volume.docker');
 
       errors.push(getters['i18n/t']('harvester.validation.vm.volume.error', { prefix, message }));
     }
   });
 
-  if (!hasImageVolumeOrExistingVolume && !value.links) {
+  if (!requiredVolume && !value.links) {
     const message = getters['i18n/t']('harvester.validation.vm.volume.needImageOrExisting');
 
     errors.push(message);
@@ -210,5 +210,12 @@ export function getVolumeType(V, DVTS) {
     };
   }
 
+  if (V.containerDisk) {
+    return {
+      type:      SOURCE_TYPE.CONTAINER,
+      typeValue: null
+    };
+  }
+
   return {};
 }

package/utils/width.js

@@ -0,0 +1,39 @@
+/**
+ * Sets the width of a DOM element. Adapted from [youmightnotneedjquery.com](https://youmightnotneedjquery.com/#set_width)
+ * @param {Element} el - The target DOM element
+ * @param {function | string | number} val - The desired width represented as a Number
+ */
+export function setWidth(el, val) {
+  if (!el) {
+    return;
+  }
+
+  if (typeof val === 'function') {
+    val = val();
+  }
+
+  if (typeof val === 'string') {
+    el.style.width = val;
+
+    return;
+  }
+
+  el.style.width = `${ val }px`;
+}
+
+/**
+ * Gets the width of a DOM element. Adapted from [youmightnotneedjquery.com](https://youmightnotneedjquery.com/#get_width)
+ * @param {Element} el - The target DOM element
+ * @returns Number representing the width for the provided element
+ */
+export function getWidth(el) {
+  if (!el || !el.length) {
+    return;
+  }
+
+  if (el.length) {
+    return parseFloat(getComputedStyle(el[0]).width.replace('px', ''));
+  } else {
+    return parseFloat(getComputedStyle(el).width.replace('px', ''));
+  }
+}