@rancher/shell 3.0.5-rc.6 → 3.0.5-rc.8

package/list/projectsecret.vue

@@ -0,0 +1,345 @@
+<script lang="ts">
+import Masthead from '@shell/components/ResourceList/Masthead';
+import { SECRET_SCOPE, SECRET_QUERY_PARAMS } from '@shell/config/query-params';
+import { MANAGEMENT, SECRET, VIRTUAL_TYPES } from '@shell/config/types';
+import { STORE } from '@shell/store/store-types';
+import PaginatedResourceTable from '@shell/components/PaginatedResourceTable';
+import { PaginationArgs, PaginationFilterField, PaginationParamFilter } from '@shell/types/store/pagination.types';
+import Secret from '@shell/models/secret';
+import { TableColumn } from '@shell/types/store/type-map';
+import { mapGetters } from 'vuex';
+import { GROUP_RESOURCES, mapPref } from '@shell/store/prefs';
+import { DEFAULT_PROJECT, SYSTEM_PROJECT, UI_PROJECT_SECRET, UI_PROJECT_SECRET_COPY } from '@shell/config/labels-annotations';
+import { RancherKubeMetadata } from '@shell/types/kube/kube-api';
+import {
+  AGE, SECRET_DATA, STATE, SUB_TYPE, NAME as NAME_COL,
+} from '@shell/config/table-headers';
+import { STEVE_AGE_COL, STEVE_NAME_COL, STEVE_STATE_COL } from '@shell/config/pagination-table-headers';
+import { escapeHtml } from '@shell/utils/string';
+
+const findSystemDefaultProjects = (projects: any[], currentClusterId: string): { systemProject?: any, defaultProject?: any } => {
+  let systemProject;
+  let defaultProject;
+
+  for (let i = 0; i < projects.length; i++) {
+    const p = projects[i];
+
+    if (p.metadata.namespace === currentClusterId) {
+      if (p.isSystem) {
+        systemProject = p;
+      }
+
+      if (p.isDefault) {
+        defaultProject = p;
+      }
+
+      if (systemProject && defaultProject) {
+        break;
+      }
+    }
+  }
+
+  return { systemProject, defaultProject };
+};
+
+export default {
+  name:       'ListProjectScopedSecrets',
+  components: { Masthead, PaginatedResourceTable },
+  props:      {
+    resource: {
+      type:     String,
+      required: true,
+    },
+
+    useQueryParamsForSimpleFiltering: {
+      type:    Boolean,
+      default: false
+    }
+  },
+
+  data() {
+    return {
+      escapeHtml,
+      SECRET,
+      PROJECT_SECRETS: VIRTUAL_TYPES.PROJECT_SECRETS,
+      STORE,
+      schema:          this.$store.getters[`${ STORE.MANAGEMENT }/schemaFor`](SECRET),
+      clusterSchema:   this.$store.getters[`${ STORE.CLUSTER }/schemaFor`](SECRET),
+      inStore:         STORE.MANAGEMENT,
+
+      projectedScopedHeaders:    [] as TableColumn[],
+      projectedScopedHeadersSsp: [] as TableColumn[],
+
+      mastheadLabel: '',
+      groupOptions:  [{
+        tooltipKey: 'resourceTable.groupBy.none',
+        icon:       'icon-list-flat',
+        value:      'none',
+      }, {
+        icon:          'icon-folder',
+        value:         'project',
+        field:         'groupByProject',
+        hideColumn:    'project',
+        groupLabelKey: 'groupByProject',
+        tooltipKey:    'resourceTable.groupBy.project'
+      }],
+
+      // these are the fields that sort will be applied on, either remotely by vai, or locally
+      sortFields: {
+        local: `groupByProject`, // would be nicer to user '`metadata.labels."${ UI_PROJECT_SECRET }"`', but that's invalid for ssp
+        vai:   `metadata.labels[${ UI_PROJECT_SECRET }]`,
+      },
+
+      systemProject:  undefined,
+      defaultProject: undefined,
+    };
+  },
+
+  async fetch() {
+    // Upstream pss's created in default and system namespaces don't follow the usual naming convention of <cluster>-<project>
+    // we use that pattern to filter out pss from other clusters
+    // in order to not also filter upstream default and system namespace also search for their exact namespace
+    // this finding them...
+    if (this.currentCluster.isLocal) {
+      // First check if we already have them
+      const projects = this.$store.getters[`${ STORE.MANAGEMENT }/all`](MANAGEMENT.PROJECT);
+      const res = findSystemDefaultProjects(projects, this.currentCluster.id);
+
+      this.defaultProject = res.defaultProject;
+      this.systemProject = res.systemProject;
+
+      if (!this.systemProject || !this.defaultProject) {
+        // If not, make a http fetch (this is blocking, but should rarely happen, and should be super quick)
+        const url = this.$store.getters[`${ STORE.MANAGEMENT }/urlFor`](MANAGEMENT.PROJECT, null, { namespaced: this.currentCluster.id });
+        const response = await this.$store.dispatch(`${ STORE.MANAGEMENT }/request`, {
+          type: MANAGEMENT.PROJECT,
+          opt:  { url: `${ url }&filter=metadata.labels[${ DEFAULT_PROJECT }]=true,metadata.labels[${ SYSTEM_PROJECT }]=true` }
+        });
+        const projects = await this.$store.dispatch(`${ STORE.MANAGEMENT }/createMany`, response.data);
+        const res = findSystemDefaultProjects(projects, this.currentCluster.id);
+
+        this.defaultProject = this.defaultProject || res.defaultProject;
+        this.systemProject = this.systemProject || res.systemProject;
+      }
+    }
+  },
+
+  async created() {
+    this.projectedScopedHeaders = [
+      STATE,
+      NAME_COL, {
+        name:   'project',
+        label:  this.t('tableHeaders.project'),
+        value:  'project.nameDisplay',
+        search: `project.nameDisplay`,
+        sort:   ['projectNameSort', 'nameSort'],
+      },
+      SUB_TYPE,
+      SECRET_DATA,
+      AGE
+    ];
+
+    this.projectedScopedHeadersSsp = [
+      STEVE_STATE_COL,
+      STEVE_NAME_COL, {
+        name:  'project',
+        label: this.t('tableHeaders.project'),
+        value: 'project.nameDisplay',
+        // blocked on https://github.com/rancher/rancher/issues/51001
+        // search: `metadata.labels[${ UI_PROJECT_SECRET }]`,
+        sort:  `metadata.labels[${ UI_PROJECT_SECRET }]`,
+      }, {
+        ...SUB_TYPE,
+        value:  'metadata.fields.1',
+        sort:   'metadata.fields.1',
+        search: 'metadata.fields.1',
+      }, {
+        ...SECRET_DATA,
+        sort:   false,
+        search: false,
+      },
+      STEVE_AGE_COL
+    ];
+
+    this.mastheadLabel = this.t(`typeLabel."${ this.resource }"`, { count: this.row?.length || 0 });
+  },
+
+  computed: {
+    ...mapGetters(['currentCluster']),
+
+    createLocation() {
+      return {
+        name:   'c-cluster-product-resource-create',
+        params: { resource: SECRET },
+        query:  { [SECRET_SCOPE]: SECRET_QUERY_PARAMS.PROJECT_SCOPED }
+      };
+    },
+
+    groupPreference: mapPref(GROUP_RESOURCES),
+
+    groupSort() {
+      return this.sortFields.local;
+    },
+
+  },
+
+  methods: {
+    /**
+     * Locally filter out secrets that are...
+     * - not project-scoped
+     * - not in current cluster (mgmt secrets are global)
+     */
+    filterRowsLocal(rows: Secret[]) {
+      return rows.filter((r: Secret) => {
+        const metadata = r.metadata as RancherKubeMetadata; // Secrets will always have metadata, but hybrid-class does nasty things which breaks typing
+
+        // Filter in pss but not the copies
+        if (!r.isProjectScoped) {
+          return;
+        }
+
+        // Filter in if this cluster
+        if (metadata.namespace.startsWith(this.currentCluster.id)) {
+          return true;
+        }
+
+        // Filter in if upstream and default/system
+        if (this.currentCluster.isLocal && (r.project?.isSystem || r.project?.isDefault)) {
+          return true;
+        }
+
+        return false;
+      });
+    },
+
+    /**
+     * Remotely filter out secrets that are..
+     * - not project-scoped
+     * - not in current cluster (mgmt secrets are global)
+     */
+    filterRowsApi(pagination: PaginationArgs): PaginationArgs {
+      const sort = pagination.sort.find((s) => s.field === this.sortFields.local);
+
+      if (sort) {
+        sort.field = this.sortFields.vai;
+      }
+
+      if (!pagination.filters) {
+        pagination.filters = [];
+      }
+
+      // Filter in pss (and annoyingly their copies)
+      const labelFilter = PaginationParamFilter.createSingleField({
+        field:  `metadata.labels[${ UI_PROJECT_SECRET }]`,
+        exists: true,
+      });
+
+      // Filter out their copies
+      const annotationFilter = PaginationParamFilter.createSingleField({
+        field:  `metadata.annotations[${ UI_PROJECT_SECRET_COPY }]`,
+        value:  `true`,
+        equals: false,
+        exact:  true,
+      });
+
+      // Filter in the current clusters pss
+      const nsFields: PaginationFilterField[] = [{
+        field:  'metadata.namespace',
+        value:  `${ this.currentCluster.id }-`,
+        equals: true,
+        exact:  false,
+      }];
+
+      let namespaceFilter;
+
+      if (this.currentCluster.isLocal) {
+        // See where these are populated, but basically filter in upstream system and default projects
+        if (this.systemProject) {
+          nsFields.push({
+            field:  'metadata.namespace',
+            value:  this.systemProject.metadata.name,
+            equals: true,
+            exact:  true,
+          });
+        }
+
+        if (this.defaultProject) {
+          nsFields.push({
+            field:  'metadata.namespace',
+            value:  this.defaultProject.metadata.name,
+            equals: true,
+            exact:  true,
+          });
+        }
+
+        namespaceFilter = PaginationParamFilter.createMultipleFields(nsFields);
+      } else {
+        namespaceFilter = PaginationParamFilter.createSingleField(nsFields[0]);
+      }
+
+      let foundLabelFilter = false;
+      let foundAnnotationFilter = false;
+      let foundNsFilter = false;
+
+      for (let i = 0; i < pagination.filters.length; i++) {
+        const filter = pagination.filters[i];
+
+        if (filter.param === namespaceFilter.fields[0].field) {
+          // 1. strip out all ns filters, this includes the one that hides resources in system namespaces...... which we need
+          // 2. use the ns filter to find upstream project scoped secrets that are in this cluster
+          pagination.filters[i] = namespaceFilter;
+          foundNsFilter = true;
+        } else {
+          if (!!filter.fields.find((f) => f.field === annotationFilter.fields[0].field)) {
+            foundAnnotationFilter = true;
+          } else if (!!filter.fields.find((f) => f.field === labelFilter.fields[0].field)) {
+            foundLabelFilter = true;
+          }
+        }
+      }
+
+      if (!foundLabelFilter) {
+        pagination.filters.push(labelFilter);
+      }
+
+      if (!foundAnnotationFilter) {
+        pagination.filters.push(annotationFilter);
+      }
+
+      if (!foundNsFilter) {
+        pagination.filters.push(namespaceFilter);
+      }
+
+      return pagination;
+    },
+
+  }
+};
+</script>
+
+<template>
+  <div v-if="!$fetchState.pending">
+    <Masthead
+      component-testid="secrets-list"
+      :schema="schema"
+      :typeDisplay="mastheadLabel"
+      :resource="SECRET"
+      :favoriteResource="PROJECT_SECRETS"
+      :create-location="createLocation"
+      :isCreatable="true"
+    />
+    <PaginatedResourceTable
+      :groupSort="groupSort"
+      :groupable="true"
+      :groupOptions="groupOptions"
+      :schema="schema"
+      :headers="projectedScopedHeaders"
+      :namespaced="false"
+      :pagination-headers="projectedScopedHeadersSsp"
+      :local-filter="filterRowsLocal"
+      :api-filter="filterRowsApi"
+      :use-query-params-for-simple-filtering="useQueryParamsForSimpleFiltering"
+      :overrideInStore="STORE.MANAGEMENT"
+    />
+  </div>
+</template>

package/list/provisioning.cattle.io.cluster.vue

@@ -10,11 +10,10 @@ import { mapFeature, HARVESTER as HARVESTER_FEATURE } from '@shell/store/feature
 import { NAME as EXPLORER } from '@shell/config/product/explorer';
 import ResourceFetch from '@shell/mixins/resource-fetch';
 import { BadgeState } from '@components/BadgeState';
-import CloudCredExpired from '@shell/components/formatter/CloudCredExpired';
 
 export default {
   components: {
-    Banner, ResourceTable, Masthead, BadgeState, CloudCredExpired
+    Banner, ResourceTable, Masthead, BadgeState
   },
   mixins: [ResourceFetch],
   props:  {
@@ -42,8 +41,6 @@ export default {
       mgmtClusters:    this.$fetchType(MANAGEMENT.CLUSTER),
     };
 
-    this.$store.dispatch('rancher/findAll', { type: NORMAN.CLOUD_CREDENTIAL });
-
     if ( this.$store.getters['management/canList'](SNAPSHOT) ) {
       hash.etcdSnapshots = this.$fetchType(SNAPSHOT);
     }
@@ -156,28 +153,6 @@ export default {
       return this.filteredRows.some((c) => c.metadata.namespace !== 'fleet-local' && c.metadata.namespace !== 'fleet-default');
     },
 
-    tokenExpiredData() {
-      const counts = this.rows.reduce((res, provCluster) => {
-        const expireData = provCluster.cloudCredential?.expireData;
-
-        if (expireData?.expiring) {
-          res.expiring++;
-        }
-        if (expireData?.expired) {
-          res.expired++;
-        }
-
-        return res;
-      }, {
-        expiring: 0,
-        expired:  0
-      });
-
-      return {
-        expiring: counts.expiring ? this.t('cluster.cloudCredentials.banners.expiring', { count: counts.expiring }) : '',
-        expired:  counts.expired ? this.t('cluster.cloudCredentials.banners.expired', { count: counts.expired }) : '',
-      };
-    }
   },
 
   $loadingResources() {
@@ -225,17 +200,6 @@ export default {
       </template>
     </Masthead>
 
-    <Banner
-      v-if="tokenExpiredData.expiring"
-      color="warning"
-      :label="tokenExpiredData.expiring"
-    />
-    <Banner
-      v-if="tokenExpiredData.expired"
-      color="error"
-      :label="tokenExpiredData.expired"
-    />
-
     <ResourceTable
       :schema="schema"
       :rows="filteredRows"
@@ -244,7 +208,6 @@ export default {
       :use-query-params-for-simple-filtering="useQueryParamsForSimpleFiltering"
       :data-testid="'cluster-list'"
       :force-update-live-and-delayed="forceUpdateLiveAndDelayed"
-      :sub-rows="true"
     >
       <!-- Why are state column and subrow overwritten here? -->
       <!-- for rke1 clusters, where they try to use the mgmt cluster stateObj instead of prov cluster stateObj,  -->
@@ -256,37 +219,6 @@ export default {
           :label="row.stateDisplay"
         />
       </template>
-      <template #sub-row="{fullColspan, row, keyField, componentTestid, i, onRowMouseEnter, onRowMouseLeave}">
-        <tr
-          :key="row[keyField] + '-description'"
-          :data-testid="componentTestid + '-' + i + '-row-description'"
-          class="state-description sub-row"
-          @mouseenter="onRowMouseEnter"
-          @mouseleave="onRowMouseLeave"
-        >
-          <td v-if="row.cloudCredentialWarning || row.stateDescription">
-&nbsp;
-          </td>
-          <td
-            v-if="row.cloudCredentialWarning || row.stateDescription"
-            :colspan="fullColspan - 1"
-          >
-            <CloudCredExpired
-              v-if="row.cloudCredentialWarning"
-              :value="row.cloudCredential.expires"
-              :row="row.cloudCredential"
-              :verbose="true"
-              :class="{'mb-10': row.stateDescription}"
-            />
-            <div
-              v-if="row.stateDescription"
-              :class="{ 'text-error' : row.stateObj.error }"
-            >
-              {{ row.stateDescription }}
-            </div>
-          </td>
-        </tr>
-      </template>
       <template #cell:summary="{row}">
         <span v-if="!row.stateParts.length">{{ row.nodes.length }}</span>
       </template>

package/list/secret.vue

@@ -0,0 +1,109 @@
+<script lang="ts">
+import Masthead from '@shell/components/ResourceList/Masthead';
+import { SECRET_SCOPE, SECRET_QUERY_PARAMS } from '@shell/config/query-params';
+import { MANAGEMENT, SECRET } from '@shell/config/types';
+import { STORE } from '@shell/store/store-types';
+import PaginatedResourceTable from '@shell/components/PaginatedResourceTable';
+import { TableColumn } from '@shell/types/store/type-map';
+import ResourceFetch from '@shell/mixins/resource-fetch';
+import { mapGetters } from 'vuex';
+import { SECRET_CLONE, SECRET_PROJECT_SCOPED } from '@shell/config/table-headers';
+import { STEVE_SECRET_CLONE } from '@shell/config/pagination-table-headers';
+
+export default {
+  name: 'ListSecret',
+
+  components: {
+    Masthead,
+    PaginatedResourceTable
+  },
+  props: {
+    resource: {
+      type:     String,
+      required: true,
+    },
+
+    schema: {
+      type:     Object,
+      required: true,
+    },
+
+    useQueryParamsForSimpleFiltering: {
+      type:    Boolean,
+      default: false
+    }
+  },
+
+  mixins: [ResourceFetch],
+
+  data() {
+    return {
+      canViewProjects:  false,
+      activeTab:        SECRET_QUERY_PARAMS.NAMESPACED,
+      SECRET_TABS:      SECRET_QUERY_PARAMS,
+      managementSchema: undefined,
+
+      STORE,
+
+      namespacedHeaders:    [] as TableColumn[],
+      namespacedHeadersSsp: [] as TableColumn[],
+    };
+  },
+
+  async created() {
+    this.canViewProjects = this.$store.getters[`${ STORE.MANAGEMENT }/schemaFor`](MANAGEMENT.PROJECT);
+    this.managementSchema = this.$store.getters[`${ STORE.MANAGEMENT }/schemaFor`](SECRET);
+    this.namespacedHeaders = this.$store.getters['type-map/headersFor'](this.schema, false) as TableColumn[];
+    this.namespacedHeadersSsp = this.$store.getters['type-map/headersFor'](this.schema, true) as TableColumn[];
+
+    const headers = this.namespacedHeaders.slice(0, -1);
+    const headersSSP = this.namespacedHeadersSsp.slice(0, -1);
+
+    if (this.canViewProjects) {
+      // if the user can see projects, add a column to let them know if it's a secret from a project scoped secret
+      headers.push(SECRET_CLONE);
+      headersSSP.push(STEVE_SECRET_CLONE);
+      if (this.currentCluster.isLocal) {
+        // if the user is on the local cluster, add a column to let them know if it's a project scoped secret (from another cluster)
+        headers.push(SECRET_PROJECT_SCOPED);
+        headersSSP.push(SECRET_PROJECT_SCOPED);
+      }
+    }
+
+    headers.push(this.namespacedHeaders[this.namespacedHeaders.length - 1]);
+    headersSSP.push(this.namespacedHeadersSsp[this.namespacedHeadersSsp.length - 1]);
+
+    this.namespacedHeaders = headers;
+    this.namespacedHeadersSsp = headersSSP;
+  },
+
+  computed: {
+    createLocation() {
+      return {
+        name:  'c-cluster-product-resource-create',
+        query: { [SECRET_SCOPE]: SECRET_QUERY_PARAMS.NAMESPACED }
+      };
+    },
+
+    ...mapGetters(['currentCluster']),
+  },
+
+};
+</script>
+
+<template>
+  <div>
+    <Masthead
+      component-testid="secrets-list"
+      :schema="schema"
+      :resource="resource"
+      :create-location="createLocation"
+    />
+    <PaginatedResourceTable
+      :schema="schema"
+      :headers="namespacedHeaders"
+      :pagination-headers="namespacedHeadersSsp"
+      :use-query-params-for-simple-filtering="useQueryParamsForSimpleFiltering"
+    />
+  </div>
+</template>

package/machine-config/__tests__/vmwarevsphere.test.ts

@@ -255,8 +255,8 @@ describe('component: vmwarevsphere', () => {
     });
   });
 
-  describe('syncNetworkValueForLegacyLabels', () => {
-    it('should update the current network value properly', () => {
+  describe('network name backwards compatibility', () => {
+    it('should NOT update the current network value to use MOID instead of name', async() => {
       const legacyName = 'legacy_name';
       const legacyValue = 'legacy_value';
       const networkLabel = 'network_label';
@@ -291,12 +291,10 @@ describe('component: vmwarevsphere', () => {
         }
       });
 
-      // check the current network before updating
-      expect(wrapper.vm.value.network).toStrictEqual([legacyName]);
-
-      wrapper.vm.syncNetworkValueForLegacyLabels();
+      await wrapper.vm.loadNetworks();
+      await wrapper.vm.$nextTick();
 
-      expect(wrapper.vm.value.network).toStrictEqual([legacyValue]);
+      expect(wrapper.vm.value.network).toStrictEqual([legacyName]);
     });
   });
 });

package/machine-config/google.vue

@@ -38,7 +38,8 @@ const defaultConfig = Object.freeze({
   vmLabels:                      '',
   username:                      'docker-user',
   setInternalFirewallRulePrefix: true,
-  setExternalFirewallRulePrefix: false
+  setExternalFirewallRulePrefix: false,
+  preemptible:                   false
 });
 
 export default {
@@ -537,6 +538,13 @@ export default {
           class="span-3"
         />
       </div>
+      <Checkbox
+        v-model:value="value.preemptible"
+        :mode="mode"
+        :label="t('cluster.machineConfig.gce.preemptible.label')"
+        :tooltip="t('cluster.machineConfig.gce.preemptible.tooltip')"
+        class="mt-20"
+      />
 
       <ArrayList
         v-model:value="scopes"

package/machine-config/vmwarevsphere.vue

@@ -340,9 +340,15 @@ export default {
 
     gracefulShutdownTimeout: integerString('value.gracefulShutdownTimeout'),
 
+    // as of 2.10.0 Rancher uses network MOID instead of network name
+    // if users have a vsphere cluster using network names instead of MOID, the UI should still display both name and MOID in the network dropdown
+    // this getter will check each value in network and, if it matches a network name (ie is not a MOID), will find the associated MOID and return that instead
+    // this does not automatically update the cluster spec to use MOID instead of name, just the display
     network: {
       get() {
-        return this.value.network || [];
+        const selectedNetworks = this.value.network || [];
+
+        return selectedNetworks.map((n) => this.networks.find((nw) => nw.name === n)?.value || n);
       },
       set(newValue) {
         set(this.value, 'network', newValue);
@@ -558,7 +564,6 @@ export default {
       this.resetValueIfNecessary('network', content, options, true);
 
       set(this, 'networksResults', content);
-      this.syncNetworkValueForLegacyLabels();
       this.vappMode = this.getInitialVappMode(this.value);
     },
 
@@ -670,21 +675,6 @@ export default {
       }
     },
 
-    // Network labels have been updated to include the MOID.
-    // To ensure previously selected networks remain consistent with this change,
-    // we update the current network value to allow correct selection from the network list.
-    syncNetworkValueForLegacyLabels() {
-      const currentNetwork = this.value.network[0];
-
-      if (this.mode !== _CREATE && currentNetwork) {
-        const networkMatch = this.networks.find((network) => currentNetwork === network.name && currentNetwork !== network.label);
-
-        if (networkMatch) {
-          this.value.network = [networkMatch.value];
-        }
-      }
-    },
-
     mapPathOptionsToContent(pathOptions) {
       return (pathOptions || []).map((pathOption) => {
         return {

package/mixins/__tests__/brand.spec.ts

@@ -99,9 +99,9 @@ describe('brandMixin', () => {
             filters: [{
               equals: true,
               fields: [{
-                equals: true, exact: true, field: 'metadata.name', value: 'rancher-csp-adapter'
+                equals: true, exact: true, exists: false, field: 'metadata.name', value: 'rancher-csp-adapter'
               }, {
-                equals: true, exact: true, field: 'metadata.name', value: 'rancher-csp-billing-adapter'
+                equals: true, exact: true, exists: false, field: 'metadata.name', value: 'rancher-csp-billing-adapter'
               }],
               param: 'filter'
             }],

package/mixins/chart.js

@@ -63,7 +63,6 @@ export default {
           label:           version.version,
           version:         version.version,
           originalVersion: version.version,
-          shortLabel:      version.version.length > 16 ? `${ version.version.slice(0, 15) }...` : version.version,
           id:              version.version,
           created:         version.created,
           disabled:        false,
@@ -93,7 +92,6 @@ export default {
         out.unshift({
           label:           selectedVersion,
           originalVersion: selectedVersion,
-          shortLabel:      selectedVersion.length > 16 ? `${ selectedVersion.slice(0, 15) }...` : selectedVersion,
           id:              selectedVersion,
           created:         null,
           disabled:        false,