@rancher/shell 0.1.0

package/models/harvester/harvesterhci.io.supportbundle.js

@@ -0,0 +1,35 @@
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class HciSupportBundle extends SteveModel {
+  get bundleState() {
+    const state = this?.status?.state;
+
+    // ready、generating
+    return state;
+  }
+
+  get bundleMessage() {
+    const state = this?.metadata?.state;
+
+    if (state.error) {
+      return state?.message;
+    }
+
+    return false;
+  }
+
+  get precent() {
+    return this?.status?.progress / 100 || 0;
+  }
+
+  get customValidationRules() {
+    return [
+      {
+        nullable:       false,
+        path:           'spec.description',
+        required:       true,
+        translationKey: 'harvester.modal.bundle.description',
+      },
+    ];
+  }
+}

package/models/harvester/harvesterhci.io.upgrade.js

@@ -0,0 +1,226 @@
+import jsyaml from 'js-yaml';
+import { NODE } from '@shell/config/types';
+import SteveModel from '@shell/plugins/steve/steve-class';
+import { colorForState } from '@shell/plugins/dashboard-store/resource-class';
+import { HCI } from '@shell/config/labels-annotations';
+
+export default class HciUpgrade extends SteveModel {
+  get isLatestUpgrade() {
+    return this?.metadata?.labels?.[HCI.LATEST_UPGRADE] === 'true';
+  }
+
+  get isUpgradeSucceeded() {
+    return this?.metadata?.labels?.[HCI.UPGRADE_STATE] === 'Succeeded';
+  }
+
+  get hasReadMessage() {
+    return this?.metadata?.labels?.[HCI.REAY_MESSAGE] === 'true';
+  }
+
+  get repoInfo() {
+    const repoInfo = this?.status?.repoInfo;
+
+    if (repoInfo) {
+      try {
+        return jsyaml.load(repoInfo);
+      } catch (e) {
+        return false;
+      }
+    }
+
+    return false;
+  }
+
+  get stateDisplay() {
+    const conditions = this?.status?.conditions || [];
+    const completedCondition = conditions.find( cond => cond.type === 'Completed');
+    const status = completedCondition?.status;
+
+    if (status === 'True') {
+      return 'Success';
+    } else if (status === 'False') {
+      return 'Fail';
+    } else {
+      return 'on-going';
+    }
+  }
+
+  get stateColor() {
+    return colorForState(this.stateDisplay);
+  }
+
+  get nodes() {
+    return this.$rootGetters['harvester/all'](NODE);
+  }
+
+  get upgradeImage() {
+    return this?.status?.imageID;
+  }
+
+  get upgradeMessage() {
+    const upgradeMessage = [];
+    const nodeStatuses = this?.status?.nodeStatuses || {};
+    const conditions = this?.status?.conditions || [];
+
+    for (const key in nodeStatuses) {
+      const state = nodeStatuses[key]?.state;
+
+      if (nodeStatuses[key] && state !== 'Succeeded' && state !== 'succeeded') {
+        upgradeMessage.push({
+          id:      key,
+          message: `The node ${ key } is ${ nodeStatuses[key]?.state }`
+        });
+      }
+    }
+
+    for (let i = 0; i < conditions.length; i++) {
+      const type = conditions[i].type;
+
+      if (type === 'systemServiceUpgraded' && conditions[i]?.status !== 'True') {
+        upgradeMessage.push({
+          id:      'systemService',
+          message: `The systemService is upgrading`
+        });
+      }
+    }
+
+    if (this.metadata?.state?.message && this.metadata?.state?.error) {
+      upgradeMessage.push({
+        id:      'message',
+        message: `${ this.metadata.state.message }`
+      });
+    }
+
+    return upgradeMessage;
+  }
+
+  get createRepo() {
+    const conditions = this?.status?.conditions || [];
+    const repoCondition = conditions.find( cond => cond.type === 'RepoReady');
+    const isReady = repoCondition?.status === 'True';
+
+    return {
+      isReady,
+      message: repoCondition?.message || repoCondition?.reason
+    };
+  }
+
+  get overallMessage() {
+    const conditions = this?.status?.conditions || [];
+    const completedCondition = conditions.find( cond => cond.type === 'Completed');
+    const hasError = completedCondition?.status === 'False';
+    const message = completedCondition?.message || completedCondition?.reason;
+
+    return hasError ? message : '';
+  }
+
+  get upgradeImageMessage() {
+    const conditions = this?.status?.conditions || [];
+    const imageReady = conditions.find( cond => cond.type === 'ImageReady');
+    const hasError = imageReady?.status === 'False';
+    const message = imageReady?.message || imageReady?.reason;
+
+    return hasError ? message : '';
+  }
+
+  get nodeUpgradeMessage() {
+    const message = [];
+    const nodeStatuses = this?.status?.nodeStatuses || {};
+
+    for (const key in nodeStatuses) {
+      const state = nodeStatuses[key]?.state;
+      const _message = nodeStatuses[key]?.message;
+
+      let percent = 0;
+
+      if (state === 'Upgrading') {
+        percent = 50;
+      } else if (state === 'Succeeded' || state === 'succeeded') {
+        percent = 100;
+      }
+
+      message.push({
+        name:    key,
+        state,
+        percent,
+        message: _message
+      });
+    }
+
+    for (const node of this.nodes) {
+      const hasNode = message.find( O => O.name === node.id);
+
+      if (!hasNode) {
+        message.push({
+          name:    node.id,
+          state:   'Pending',
+          percent: 0,
+        });
+      }
+    }
+
+    return message;
+  }
+
+  get nodeTotalPercent() {
+    let out = 0;
+
+    for (let i = 0; i < this.nodeUpgradeMessage.length; i++) {
+      out += this.nodeUpgradeMessage[i].percent;
+    }
+
+    out = Math.floor(out / this.nodeUpgradeMessage.length);
+    const conditions = this?.status?.conditions || [];
+    const nodeUpgradedCondition = conditions.find( cond => cond.type === 'NodesUpgraded');
+
+    if (out === 100 && !nodeUpgradedCondition) {
+      out = 99;
+    }
+
+    return out;
+  }
+
+  get sysServiceUpgradeMessage() {
+    let percent = 0;
+    let state = 'Pending';
+    const message = [];
+    const conditions = this?.status?.conditions || [];
+
+    for (let i = 0; i < conditions.length; i++) {
+      const type = conditions[i].type;
+
+      if (type === 'SystemServicesUpgraded') {
+        if (conditions[i].status === 'True') {
+          percent = 100;
+          state = 'Succeeded';
+        } else {
+          percent = 50;
+        }
+
+        message.push({
+          name:    'system services',
+          state,
+          percent,
+          message: conditions[i]?.message
+        });
+      }
+    }
+
+    if (message.length === 0) {
+      message.push({
+        name: 'system services',
+        state,
+        percent,
+      });
+    }
+
+    return message;
+  }
+
+  get totalPercent() {
+    const nodePercent = this.nodeTotalPercent * this.nodeUpgradeMessage.length;
+    const servicePercent = this.sysServiceUpgradeMessage?.[0].percent;
+
+    return Math.floor((nodePercent + servicePercent) / (this.nodeUpgradeMessage.length + 1));
+  }
+}

package/models/harvester/harvesterhci.io.virtualmachinebackup.js

@@ -0,0 +1,113 @@
+import { HCI } from '@shell/config/types';
+import { get } from '@shell/utils/object';
+import { findBy } from '@shell/utils/array';
+import { colorForState } from '@shell/plugins/dashboard-store/resource-class';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class HciVmBackup extends SteveModel {
+  detailPageHeaderActionOverride() {
+    return this.t('harvester.backup.title');
+  }
+
+  get _availableActions() {
+    const toFilter = ['goToEdit', 'cloneYaml', 'goToClone', 'download'];
+
+    const out = super._availableActions.filter((action) => {
+      if (!toFilter.includes(action.action)) {
+        return action;
+      }
+    });
+
+    const schema = this.$getters['schemaFor'](HCI.VM);
+    let canCreateVM = true;
+
+    if ( schema && !schema?.collectionMethods.find(x => ['post'].includes(x.toLowerCase())) ) {
+      canCreateVM = false;
+    }
+
+    return [
+      {
+        action:     'restoreExistingVM',
+        enabled:    canCreateVM && this.attachVmExisting && this?.status?.readyToUse,
+        icon:       'icons icon-refresh',
+        label:      this.t('harvester.action.restoreExistingVM'),
+      },
+      {
+        action:     'restoreNewVM',
+        enabled:    canCreateVM && this?.status?.readyToUse,
+        icon:       'icons icon-backup',
+        label:      this.t('harvester.action.restoreNewVM'),
+      },
+      ...out
+    ];
+  }
+
+  restoreExistingVM(resource = this) {
+    const router = this.currentRouter();
+
+    router.push({
+      name:   `c-cluster-product-resource-create`,
+      params: { resource: HCI.BACKUP },
+      query:  { restoreMode: 'existing', backupName: resource.name }
+    });
+  }
+
+  restoreNewVM(resource = this) {
+    const router = this.currentRouter();
+
+    router.push({
+      name:   `c-cluster-product-resource-create`,
+      params: { resource: HCI.BACKUP },
+      query:  { restoreMode: 'new', backupName: resource.name }
+    });
+  }
+
+  get state() {
+    let out = 'Pending';
+    const conditions = get(this, 'status.conditions');
+    const isProgress = findBy(conditions, 'type', 'InProgress')?.status === 'True';
+    const isReady = findBy(conditions, 'type', 'Ready')?.status === 'True';
+
+    if (this?.status?.readyToUse) {
+      out = 'Ready';
+    } else if (isProgress) {
+      out = 'Progressing';
+    } else if (!isReady) {
+      out = 'error';
+    }
+
+    return out;
+  }
+
+  get stateColor() {
+    const state = this.state;
+
+    return colorForState(state);
+  }
+
+  get attachVM() {
+    return this.spec.source.name;
+  }
+
+  get backupContentName() {
+    return this?.status?.virtualMachineBackupContentName || '';
+  }
+
+  get backupTarget() {
+    return this?.status?.backupTarget?.endpoint || '';
+  }
+
+  get attachVmExisting() {
+    const vmList = this.$rootGetters['harvester/all'](HCI.VM);
+
+    return !!vmList.find( V => V.metadata.name === this.attachVM);
+  }
+
+  remove() {
+    const opt = { ...arguments };
+
+    opt.params = { propagationPolicy: 'Foreground' };
+
+    return this._remove(opt);
+  }
+}

package/models/harvester/harvesterhci.io.virtualmachineimage.js

@@ -0,0 +1,252 @@
+import Vue from 'vue';
+import { HCI } from '@shell/config/types';
+import {
+  DESCRIPTION,
+  ANNOTATIONS_TO_IGNORE_REGEX,
+  HCI as HCI_ANNOTATIONS
+} from '@shell/config/labels-annotations';
+import { get, clone } from '@shell/utils/object';
+import { formatSi } from '@shell/utils/units';
+import { ucFirst } from '@shell/utils/string';
+import { stateDisplay, colorForState } from '@shell/plugins/dashboard-store/resource-class';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export function isReady() {
+  function getStatusConditionOfType(type, defaultValue = []) {
+    const conditions = Array.isArray(get(this, 'status.conditions')) ? this.status.conditions : defaultValue;
+
+    return conditions.find( cond => cond.type === type);
+  }
+
+  const initialized = getStatusConditionOfType.call(this, 'Initialized');
+  const imported = getStatusConditionOfType.call(this, 'Imported');
+  const isCompleted = this.status?.progress === 100;
+
+  if ([initialized?.status, imported?.status].includes('False')) {
+    return false;
+  } else {
+    return isCompleted && true;
+  }
+}
+export default class HciVmImage extends SteveModel {
+  get availableActions() {
+    let out = super._availableActions;
+    const toFilter = ['goToEditYaml'];
+
+    out = out.filter( A => !toFilter.includes(A.action));
+
+    const schema = this.$getters['schemaFor'](HCI.VM);
+    let canCreateVM = true;
+
+    if ( schema && !schema?.collectionMethods.find(x => ['post'].includes(x.toLowerCase())) ) {
+      canCreateVM = false;
+    }
+
+    return [
+      {
+        action:     'createFromImage',
+        enabled:    canCreateVM,
+        icon:       'icon icon-fw icon-spinner',
+        label:      this.t('harvester.action.createVM'),
+        disabled:   !this.isReady,
+      },
+      ...out
+    ];
+  }
+
+  applyDefaults(resources = this, realMode) {
+    Vue.set(this.metadata, 'labels', { [HCI_ANNOTATIONS.OS_TYPE]: '', [HCI_ANNOTATIONS.IMAGE_SUFFIX]: '' });
+  }
+
+  createFromImage() {
+    const router = this.currentRouter();
+
+    router.push({
+      name:   `c-cluster-product-resource-create`,
+      params: { resource: HCI.VM },
+      query:  { image: this.id }
+    });
+  }
+
+  get nameDisplay() {
+    return this.spec?.displayName;
+  }
+
+  get isOSImage() {
+    return this?.metadata?.annotations?.[HCI_ANNOTATIONS.OS_UPGRADE_IMAGE] === 'True';
+  }
+
+  get isReady() {
+    return isReady.call(this);
+  }
+
+  get stateDisplay() {
+    const initialized = this.getStatusConditionOfType('Initialized');
+    const imported = this.getStatusConditionOfType('Imported');
+
+    if (imported?.status === 'Unknown') {
+      if (this.spec.sourceType === 'download') {
+        return 'Downloading';
+      } else if (this.spec.sourceType === 'upload') {
+        return 'Uploading';
+      } else {
+        return 'Exporting';
+      }
+    }
+
+    if (initialized?.message || imported?.message) {
+      return 'Failed';
+    }
+
+    return stateDisplay(this.metadata.state.name);
+  }
+
+  get imageMessage() {
+    const conditions = this?.status?.conditions || [];
+    const initialized = conditions.find( cond => cond.type === 'Initialized');
+    const imported = conditions.find( cond => cond.type === 'Imported');
+    const message = initialized?.message || imported?.message;
+
+    return ucFirst(message);
+  }
+
+  get stateBackground() {
+    return colorForState(this.stateDisplay).replace('text-', 'bg-');
+  }
+
+  get imageSource() {
+    return get(this, `spec.sourceType`) || 'download';
+  }
+
+  get progress() {
+    return this?.status?.progress || 0;
+  }
+
+  get annotationsToIgnoreRegexes() {
+    return [DESCRIPTION].concat(ANNOTATIONS_TO_IGNORE_REGEX);
+  }
+
+  get downSize() {
+    const size = this.status?.size;
+
+    if (!size) {
+      return '-';
+    }
+
+    return formatSi(size, {
+      increment:    1024,
+      maxPrecision: 2,
+      suffix:       'B',
+      firstSuffix:  'B',
+    });
+  }
+
+  getStatusConditionOfType(type, defaultValue = []) {
+    const conditions = Array.isArray(get(this, 'status.conditions')) ? this.status.conditions : defaultValue;
+
+    return conditions.find( cond => cond.type === type);
+  }
+
+  get stateObj() {
+    const state = clone(this.metadata?.state);
+    const initialized = this.getStatusConditionOfType('Initialized');
+    const imported = this.getStatusConditionOfType('Imported');
+
+    if ([initialized?.status, imported?.status].includes('False')) {
+      state.error = true;
+    }
+
+    return state;
+  }
+
+  get stateDescription() {
+    return this.imageMessage;
+  }
+
+  get displayName() {
+    return this.spec?.displayName;
+  }
+
+  get uploadImage() {
+    return async(file) => {
+      const formData = new FormData();
+
+      formData.append('chunk', file);
+
+      try {
+        this.$ctx.commit('harvester-common/uploadStart', this.metadata.name, { root: true });
+
+        await this.doAction('upload', formData, {
+          headers: {
+            'Content-Type': 'multipart/form-data',
+            'File-Size':    file.size,
+          },
+          params: { size: file.size },
+        });
+      } catch (err) {
+        this.$ctx.commit('harvester-common/uploadEnd', this.metadata.name, { root: true });
+
+        return Promise.reject(err);
+      }
+
+      this.$ctx.commit('harvester-common/uploadEnd', this.metadata.name, { root: true });
+    };
+  }
+
+  get imageSuffix() {
+    return this.metadata?.labels?.[HCI_ANNOTATIONS.IMAGE_SUFFIX];
+  }
+
+  get imageOSType() {
+    return this.metadata?.labels?.[HCI_ANNOTATIONS.OS_TYPE];
+  }
+
+  get customValidationRules() {
+    const out = [];
+
+    if (this.imageSource === 'download') {
+      const urlFormat = {
+        nullable:       false,
+        path:           'spec.url',
+        validators:     ['imageUrl'],
+      };
+
+      const urlRequired = {
+        nullable:       false,
+        path:           'spec.url',
+        required:       true,
+        translationKey: 'harvester.image.url'
+      };
+
+      out.push(urlFormat, urlRequired);
+    }
+
+    if (this.imageSource === 'upload') {
+      const fileRequired = {
+        nullable:       false,
+        path:           'metadata.annotations',
+        validators:     ['fileRequired'],
+      };
+
+      out.push(fileRequired);
+    }
+
+    return [
+      {
+        nullable:       false,
+        path:           'spec.displayName',
+        required:       true,
+        minLength:      1,
+        maxLength:      63,
+        translationKey: 'generic.name'
+      },
+      {
+        nullable:       false,
+        path:           'spec.displayName',
+        required:       true,
+        translationKey: 'generic.name'
+      },
+      ...out
+    ];
+  }
+}

package/models/harvester/harvesterhci.io.virtualmachinerestore.js

@@ -0,0 +1,43 @@
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class HciVmRestore extends SteveModel {
+  get isComplete() {
+    return this?.status?.complete || false;
+  }
+
+  get pvcNames() {
+    const restores = this?.status?.restores || [];
+    const out = restores.map( O => O?.persistentVolumeClaimSpec?.name);
+
+    return out;
+  }
+
+  get customValidationRules() {
+    const isNew = this.spec?.newVM;
+
+    const rules = [{
+      nullable:       false,
+      path:           'spec.target.name',
+      required:       true,
+      minLength:      1,
+      maxLength:      63,
+      translationKey: 'harvester.fields.virtualName',
+    }, {
+      nullable:       false,
+      path:           'spec.virtualMachineBackupName',
+      required:       true,
+      translationKey: 'harvester.backup.restore.backup',
+    }];
+
+    if (!isNew) {
+      rules.push({
+        path:           'spec.deletionPolicy',
+        required:       true,
+        type:           'string',
+        translationKey: 'harvester.backup.restore.deletePreviousVolumes',
+      });
+    }
+
+    return rules;
+  }
+}