@rancher/shell 0.1.0

package/models/fleet.cattle.io.clustergroup.js

@@ -0,0 +1,62 @@
+import { escapeHtml } from '@shell/utils/string';
+import { matching, convert } from '@shell/utils/selector';
+import { FLEET } from '@shell/config/types';
+import { set } from '@shell/utils/object';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class FleetClusterGroup extends SteveModel {
+  applyDefaults() {
+    const spec = this.spec || {};
+
+    spec.selector = spec.selector || {};
+    spec.selector.matchExpressions = spec.selector.matchExpressions || [];
+
+    set(this, 'spec', spec);
+  }
+
+  get targetClusters() {
+    const workspace = this.$getters['byId'](FLEET.WORKSPACE, this.metadata.namespace);
+    const expressions = convert(this.spec?.selector?.matchLabels || {}, this.spec?.selector?.matchExpressions || []);
+
+    if ( !expressions.length ) {
+      return workspace.clusters;
+    }
+
+    const match = matching(workspace.clusters, expressions);
+
+    return match;
+  }
+
+  get groupByLabel() {
+    const name = this.metadata.namespace;
+
+    if ( name ) {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.workspace', { name: escapeHtml(name) });
+    } else {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.notInAWorkspace');
+    }
+  }
+
+  get clusterInfo() {
+    const total = this.status?.clusterCount || 0;
+    const unready = this.status?.nonReadyClusterCount || 0;
+    const ready = total - unready;
+
+    return {
+      ready,
+      unready,
+      total,
+    };
+  }
+
+  get details() {
+    const out = [
+      {
+        label:   'Clusters Ready',
+        content:  `${ this.clusterInfo.ready } of ${ this.clusterInfo.total }`,
+      },
+    ];
+
+    return out;
+  }
+}

package/models/fleet.cattle.io.clusterregistrationtoken.js

@@ -0,0 +1,14 @@
+import { escapeHtml } from '@shell/utils/string';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class FleetToken extends SteveModel {
+  get groupByLabel() {
+    const name = this.metadata.namespace;
+
+    if ( name ) {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.workspace', { name: escapeHtml(name) });
+    } else {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.notInAWorkspace');
+    }
+  }
+}

package/models/fleet.cattle.io.gitrepo.js

@@ -0,0 +1,315 @@
+import { convert, matching, convertSelectorObj } from '@shell/utils/selector';
+import jsyaml from 'js-yaml';
+import { escapeHtml } from '@shell/utils/string';
+import { FLEET } from '@shell/config/types';
+import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
+import { addObject, addObjects, findBy, insertAt } from '@shell/utils/array';
+import { set } from '@shell/utils/object';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+function quacksLikeAHash(str) {
+  if ( str.match(/^[a-f0-9]{40,}$/i) ) {
+    return true;
+  }
+
+  return false;
+}
+
+export default class GitRepo extends SteveModel {
+  applyDefaults() {
+    const spec = this.spec || {};
+    const meta = this.metadata || {};
+
+    meta.namespace = this.$rootGetters['workspace'];
+
+    spec.repo = spec.repo || '';
+
+    if ( !spec.branch && !spec.revision ) {
+      spec.branch = 'master';
+    }
+
+    spec.paths = spec.paths || [];
+    spec.clientSecretName = spec.clientSecretName || null;
+
+    set(this, 'spec', spec);
+    set(this, 'metadata', meta);
+  }
+
+  get _availableActions() {
+    const out = super._availableActions;
+
+    insertAt(out, 0, {
+      action:     'pause',
+      label:      'Pause',
+      icon:       'icon icon-pause',
+      bulkable:    true,
+      enabled:    !!this.links.update && !this.spec?.paused
+    });
+
+    insertAt(out, 1, {
+      action:     'unpause',
+      label:      'Unpause',
+      icon:       'icon icon-play',
+      bulkable:    true,
+      enabled:    !!this.links.update && this.spec?.paused === true
+    });
+
+    insertAt(out, 2, {
+      action:     'forceUpdate',
+      label:      'Force Update',
+      icon:       'icon icon-refresh',
+      bulkable:    true,
+      enabled:    !!this.links.update
+    });
+
+    insertAt(out, 3, { divider: true });
+
+    return out;
+  }
+
+  pause() {
+    this.spec.paused = true;
+    this.save();
+  }
+
+  unpause() {
+    this.spec.paused = false;
+    this.save();
+  }
+
+  forceUpdate() {
+    const now = this.spec.forceSyncGeneration || 1;
+
+    this.spec.forceSyncGeneration = now + 1;
+    this.save();
+  }
+
+  get state() {
+    if ( this.spec?.paused === true ) {
+      return 'paused';
+    }
+
+    return this.metadata?.state?.name || 'unknown';
+  }
+
+  get targetClusters() {
+    const workspace = this.$getters['byId'](FLEET.WORKSPACE, this.metadata.namespace);
+    const clusters = workspace?.clusters || [];
+    const groups = workspace?.clusterGroups || [];
+    const out = [];
+
+    if ( workspace.id === 'fleet-local' ) {
+      const local = findBy(groups, 'id', 'fleet-local/default');
+
+      if ( local ) {
+        return local.targetClusters;
+      }
+
+      return [];
+    }
+
+    for ( const tgt of this.spec.targets ) {
+      if ( tgt.clusterName ) {
+        const cluster = findBy(clusters, 'metadata.name', tgt.clusterName);
+
+        if ( cluster ) {
+          addObject(out, cluster);
+        }
+      } else if ( tgt.clusterGroup ) {
+        const group = findBy(groups, {
+          'metadata.namespace': this.metadata.namespace,
+          'metadata.name':      tgt.clusterGroup,
+        });
+
+        if ( group ) {
+          addObjects(out, group.targetClusters);
+        }
+      } else if ( tgt.clusterGroupSelector ) {
+        const expressions = convertSelectorObj(tgt.clusterGroupSelector);
+        const matchingGroups = matching(groups, expressions);
+
+        for ( const group of matchingGroups ) {
+          addObjects(out, group.targetClusters);
+        }
+      } else if ( tgt.clusterSelector ) {
+        const expressions = convertSelectorObj(tgt.clusterSelector);
+        const matchingClusters = matching(clusters, expressions);
+
+        addObjects(out, matchingClusters);
+      }
+    }
+
+    return out;
+  }
+
+  get github() {
+    const match = this.spec.repo.match(/^https?:\/\/github\.com\/(.*?)(\.git)?\/*$/);
+
+    if ( match ) {
+      return match[1];
+    }
+
+    return false;
+  }
+
+  get repoIcon() {
+    if ( this.github ) {
+      return 'icon icon-github';
+    }
+
+    return '';
+  }
+
+  get repoDisplay() {
+    let repo = this.spec.repo;
+
+    repo = repo.replace(/.git$/, '');
+    repo = repo.replace(/^https:\/\//, '');
+    repo = repo.replace(/\/+$/, '');
+
+    if ( this.github ) {
+      return this.github;
+    }
+
+    return repo;
+  }
+
+  get commitDisplay() {
+    const spec = this.spec;
+    const hash = this.status?.commit?.substr(0, 7);
+
+    if ( !spec || !spec.repo ) {
+      return null;
+    }
+
+    if ( spec.revision && quacksLikeAHash(spec.revision) ) {
+      return spec.revision.substr(0, 7);
+    } else if ( spec.revision ) {
+      return spec.revision;
+    } else if ( spec.branch ) {
+      return spec.branch + (hash ? ` @ ${ hash }` : '');
+    }
+
+    return hash;
+  }
+
+  get clusterInfo() {
+    const ready = this.status?.readyClusters || 0;
+    const total = this.status?.desiredReadyClusters || 0;
+
+    return {
+      ready,
+      unready: total - ready,
+      total,
+    };
+  }
+
+  get targetInfo() {
+    let mode = null;
+    let cluster = null;
+    let clusterGroup = null;
+    let advanced = null;
+
+    const targets = this.spec.targets || [];
+
+    advanced = jsyaml.dump(targets);
+
+    if ( advanced === '[]\n' ) {
+      advanced = `# - name:
+#  clusterSelector:
+#    matchLabels:
+#     foo: bar
+#    matchExpressions:
+#     - key: foo
+#       op: In
+#       values: [bar, baz]
+#  clusterGroup: foo
+#  clusterGroupSelector:
+#    matchLabels:
+#     foo: bar
+#    matchExpressions:
+#     - key: foo
+#       op: In
+#       values: [bar, baz]
+`;
+    }
+
+    if ( this.metadata.namespace === 'fleet-local' ) {
+      mode = 'local';
+    } else if ( !targets.length ) {
+      mode = 'none';
+    } else if ( targets.length === 1) {
+      const target = targets[0];
+
+      if (Object.keys(target).length > 1) {
+        // There are multiple properties in a single target, so use the 'advanced' mode
+        // (otherwise any existing content is nuked for what we provide)
+        mode = 'advanced';
+      } else if ( target.clusterGroup ) {
+        clusterGroup = target.clusterGroup;
+
+        if ( !mode ) {
+          mode = 'clusterGroup';
+        }
+      } else if ( target.clusterName ) {
+        mode = 'cluster';
+        cluster = target.clusterName;
+      } else if ( target.clusterSelector ) {
+        if ( Object.keys(target.clusterSelector).length === 0 ) {
+          mode = 'all';
+        } else {
+          const expressions = convert(target.clusterSelector.matchLabels, target.clusterSelector.matchExpressions);
+
+          if ( expressions.length === 1 &&
+              expressions[0].key === FLEET_ANNOTATIONS.CLUSTER_NAME &&
+              expressions[0].operator === 'In' &&
+              expressions[0].values.length === 1
+          ) {
+            cluster = expressions[0].values[0];
+            if ( !mode ) {
+              mode = 'cluster';
+            }
+          }
+        }
+      }
+    }
+
+    if ( !mode ) {
+      mode = 'advanced';
+    }
+
+    return {
+      mode,
+      modeDisplay: this.t(`fleet.gitRepo.targetDisplay."${ mode }"`),
+      cluster,
+      clusterGroup,
+      advanced
+    };
+  }
+
+  get groupByLabel() {
+    const name = this.metadata.namespace;
+
+    if ( name ) {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.workspace', { name: escapeHtml(name) });
+    } else {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.notInAWorkspace');
+    }
+  }
+
+  get bundles() {
+    const all = this.$getters['all'](FLEET.BUNDLE);
+
+    return all.filter(bundle => bundle.name.startsWith(`${ this.name }-`) &&
+      bundle.namespace === this.namespace &&
+      bundle.namespacedName.startsWith(`${ this.namespace }:${ this.name }`));
+  }
+
+  get bundlesReady() {
+    if (this.bundles && this.bundles.length) {
+      return this.bundles.filter(bundle => bundle.state === 'active');
+    }
+
+    return 0;
+  }
+}

package/models/group.principal.js

@@ -0,0 +1,71 @@
+import { MANAGEMENT, NORMAN } from '@shell/config/types';
+import { clone } from '@shell/utils/object';
+import Principal from './principal';
+
+export default class Group extends Principal {
+  get canViewInApi() {
+    return false;
+  }
+
+  get nameDisplay() {
+    return this.principalNameDisplay;
+  }
+
+  get principalNameDisplay() {
+    const principal = this.$rootGetters['rancher/byId'](NORMAN.PRINCIPAL, this.id);
+
+    return `${ principal.name } (${ principal.displayType })`;
+  }
+
+  get detailLocation() {
+    const detailLocation = clone(this._detailLocation);
+
+    detailLocation.params.id = this.id; // Base fn removes part of the id (`github_team://3375666` --> `3375666`)
+
+    return detailLocation;
+  }
+
+  get globalRoleBindings() {
+    return this.$rootGetters['management/all'](MANAGEMENT.GLOBAL_ROLE_BINDING)
+      .filter(globalRoleBinding => this.id === globalRoleBinding.groupPrincipalName);
+  }
+
+  get _availableActions() {
+    return [
+      {
+        action:  'goToEdit',
+        label:   this.t('action.edit'),
+        icon:    'icon icon-edit',
+        enabled:  true,
+      },
+      {
+        action:     'promptUnassignGroupRoles',
+        altAction:  'unassignGroupRoles',
+        label:      this.t('action.unassign'),
+        icon:       'icon icon-trash',
+        bulkable:   true,
+        enabled:    !!this.globalRoleBindings.length,
+        bulkAction: 'unassignGroupRoles',
+      },
+    ];
+  }
+
+  promptUnassignGroupRoles(resources = this) {
+    const principals = Array.isArray(resources) ? resources : [resources];
+    const globalRoleBindings = this.$rootGetters['management/all'](MANAGEMENT.GLOBAL_ROLE_BINDING)
+      .filter(globalRoleBinding => principals.find(principal => principal.id === globalRoleBinding.groupPrincipalName));
+
+    this.$dispatch('promptRemove', globalRoleBindings);
+  }
+
+  async unassignGroupRoles(resources = this) {
+    const principals = Array.isArray(resources) ? resources : [resources];
+    const globalRoleBindings = this.$rootGetters['management/all'](MANAGEMENT.GLOBAL_ROLE_BINDING)
+      .filter(globalRoleBinding => principals.find(principal => principal.id === globalRoleBinding.groupPrincipalName));
+
+    await Promise.all(globalRoleBindings.map(resource => resource.remove()));
+
+    // There is no dialog to close, but this can be watched and used to refresh the group principles
+    this.$dispatch('promptRemove', null);
+  }
+}

package/models/harvester/configmap.js

@@ -0,0 +1,32 @@
+import { clone } from '@shell/utils/object';
+import { HCI } from '@shell/config/types';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class HciConfigMap extends SteveModel {
+  get detailLocation() {
+    const detailLocation = clone(this._detailLocation);
+
+    detailLocation.params.resource = HCI.CLOUD_TEMPLATE;
+
+    return detailLocation;
+  }
+
+  get doneOverride() {
+    const detailLocation = clone(this._detailLocation);
+
+    delete detailLocation.params.namespace;
+    delete detailLocation.params.id;
+    detailLocation.params.resource = HCI.CLOUD_TEMPLATE;
+    detailLocation.name = 'c-cluster-product-resource';
+
+    return detailLocation;
+  }
+
+  get parentNameOverride() {
+    return this.$rootGetters['i18n/t'](`typeLabel."${ HCI.CLOUD_TEMPLATE }"`, { count: 1 })?.trim();
+  }
+
+  get parentLocationOverride() {
+    return this.doneOverride;
+  }
+}

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

@@ -0,0 +1,55 @@
+import { HCI } from '@shell/config/types';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class HciBlockDevice extends SteveModel {
+  get childParts() {
+    const inStore = this.$rootGetters['currentProduct'].inStore;
+    const bds = this.$rootGetters[`${ inStore }/all`](HCI.BLOCK_DEVICE);
+
+    const parts = bds.filter((b) => {
+      return b.status?.deviceStatus?.parentDevice === this.spec?.devPath &&
+              b.spec.nodeName === this.spec.nodeName;
+    });
+
+    return parts;
+  }
+
+  get isChildPartProvisioned() {
+    const parts = this.childParts.filter(p => p.spec?.fileSystem?.provisioned) || [];
+
+    return parts.length > 0;
+  }
+
+  get provisionPhase() {
+    const label = this?.status?.provisionPhase;
+    let color = '';
+    let icon = '';
+
+    switch (label) {
+    case 'Provisioned':
+      color = 'bg-success';
+      icon = 'icon-checkmark';
+      break;
+    case 'Unprovisioning':
+      color = 'bg-warning';
+      icon = 'icon-warning';
+      break;
+    case 'NotProvisioned':
+      color = 'bg-error';
+      icon = 'icon-warning';
+      break;
+    default:
+      break;
+    }
+
+    return {
+      label,
+      color,
+      icon,
+    };
+  }
+
+  get displayName() {
+    return this.status?.deviceStatus?.devPath || this?.metadata?.name;
+  }
+}

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

@@ -0,0 +1,12 @@
+import { get } from '@shell/utils/object';
+import { findBy } from '@shell/utils/array';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export default class HciKeypair extends SteveModel {
+  get stateDisplay() {
+    const conditions = get(this, 'status.conditions');
+    const status = (findBy(conditions, 'type', 'validated') || {}).status ;
+
+    return status === 'True' ? 'Validated' : 'Not Validated';
+  }
+}

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

@@ -0,0 +1,127 @@
+import { findBy } from '@shell/utils/array';
+import { HCI } from '@shell/config/types';
+import SteveModel from '@shell/plugins/steve/steve-class';
+import { HCI_ALLOWED_SETTINGS, HCI_SETTING } from '@shell/config/settings';
+
+export default class HciSetting extends SteveModel {
+  get _availableActions() {
+    const toFilter = ['cloneYaml', 'download', 'goToEditYaml', 'goToViewYaml', 'goToViewConfig', 'promptRemove'];
+    const settingMetadata = HCI_ALLOWED_SETTINGS[this.id];
+
+    let out = super._availableActions;
+
+    // Some settings are not editable
+    if ( settingMetadata?.readOnly || this.fromEnv ) {
+      toFilter.push('goToEdit');
+    }
+
+    out = out.filter((action) => {
+      return (!toFilter.includes(action.action));
+    });
+
+    // Change the label on the first action (edit)
+    const editAction = out.find(action => action.action === 'goToEdit');
+
+    if (editAction) {
+      editAction.label = this.t('advancedSettings.edit.label');
+    }
+
+    const schema = this.$getters['schemaFor'](HCI.UPGRADE);
+    const hasUpgradeAccess = !!schema?.collectionMethods.find(x => ['post'].includes(x.toLowerCase()));
+
+    if (this.id === HCI_SETTING.SERVER_VERSION && hasUpgradeAccess) {
+      const latestUpgrade = this.$getters['all'](HCI.UPGRADE).find(upgrade => upgrade.isLatestUpgrade);
+
+      out.unshift({
+        action:   'goToAirgapUpgrade',
+        enabled:  true,
+        icon:     'icon icon-refresh',
+        label:    this.t('harvester.upgradePage.upgrade'),
+        disabled: !!latestUpgrade && !latestUpgrade?.isUpgradeSucceeded
+      });
+    }
+
+    return out;
+  }
+
+  goToAirgapUpgrade() {
+    const router = this.currentRouter();
+
+    router.push({
+      name:   'c-cluster-harvester-airgapupgrade',
+      params: { cluster: this.$rootGetters['currentCluster'].id, product: 'harvester' },
+    });
+  }
+
+  get backupTargetIsEmpty() {
+    return !this.value;
+  }
+
+  get errMessage() {
+    if (this.metadata?.state?.error === true) {
+      return this.metadata.state.message;
+    } else {
+      return false;
+    }
+  }
+
+  get configuredCondition() {
+    return findBy((this?.status?.conditions || []), 'type', 'configured') || {};
+  }
+
+  get valueOrDefaultValue() {
+    return this.value || this.default;
+  }
+
+  get currentVersion() {
+    return this.value || '';
+  }
+
+  get displayValue() { // Select the field you want to display
+    if (this.id === 'backup-target') {
+      return this.parseValue?.endpoint || ' ';
+    }
+
+    return null;
+  }
+
+  get parseValue() {
+    let parseDefaultValue = {};
+
+    try {
+      parseDefaultValue = JSON.parse(this.value);
+    } catch (err) {
+      parseDefaultValue = JSON.parse(this.default);
+    }
+
+    return parseDefaultValue;
+  }
+
+  get isS3() {
+    return this.parseValue.type === 's3';
+  }
+
+  get isNFS() {
+    return this.parseValue.type === 'nfs';
+  }
+
+  get customValidationRules() {
+    const id = this.id;
+
+    const out = [];
+
+    switch (id) {
+    case 'backup-target':
+      out.push( {
+        nullable:       false,
+        path:           'value',
+        required:       true,
+        type:           'string',
+        validators:     ['backupTarget'],
+      });
+      break;
+    }
+
+    return out;
+  }
+}