@rancher/shell 2.0.2-rc.1 → 2.0.3

package/utils/auth.js

@@ -99,7 +99,7 @@ export const checkSchemasForFindAllHash = (types, store) => {
     const validSchema = value.schemaValidator ? value.schemaValidator(schema) : !!schema;
 
     if (validSchema) {
-      hash[key] = store.dispatch(`${ value.inStoreType }/findAll`, { type: value.type } );
+      hash[key] = store.dispatch(`${ value.inStoreType }/findAll`, { type: value.type, opt: value.opt } );
     }
   }
 

package/utils/cluster.js

@@ -94,7 +94,7 @@ export function abbreviateClusterName(input) {
 
 export function labelForAddon(name, configuration = true) {
   const addon = camelToTitle(name.replace(/^(rke|rke2|rancher)-/, ''));
-  const fallback = `${ addon } ${ configuration ? 'Configuration' : '' }`;
+  const fallback = `${ configuration ? '' : 'Add-on: ' }${ addon }`;
   const key = `cluster.addonChart."${ name }"${ configuration ? '.configuration' : '.label' }`;
 
   return this.$store.getters['i18n/withFallback'](key, null, fallback);

package/utils/fleet.ts

@@ -0,0 +1,159 @@
+import {
+  BundleDeploymentResource,
+  BundleResourceKey,
+  BundleDeploymentStatus,
+  BundleStatus,
+} from '@shell/types/resources/fleet';
+import { STATES_ENUM } from '@shell/plugins/dashboard-store/resource-class';
+import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
+
+interface Resource extends BundleDeploymentResource {
+  state: string,
+}
+
+type Labels = {
+  [key: string]: string,
+}
+
+interface StatesCounter { [state: string]: number }
+
+function incr(counter: StatesCounter, state: string) {
+  if (!counter[state]) {
+    counter[state] = 0;
+  }
+  counter[state]++;
+}
+
+function resourceKey(r: BundleResourceKey): string {
+  return `${ r.kind }/${ r.namespace }/${ r.name }`;
+}
+
+class Fleet {
+  resourceId(r: BundleResourceKey): string {
+    return r.namespace ? `${ r.namespace }/${ r.name }` : r.name;
+  }
+
+  /**
+   * resourceType normalizes APIVersion and Kind from a Resources into a single string
+   */
+  resourceType(r: Resource): string {
+    // ported from https://github.com/rancher/fleet/blob/v0.10.0/internal/cmd/controller/grutil/resourcekey.go#L116-L128
+    const type = r.kind.toLowerCase();
+
+    if (!r.apiVersion || r.apiVersion === 'v1') {
+      return type;
+    }
+
+    return `${ r.apiVersion.split('/', 2)[0] }.${ type }`;
+  }
+
+  /**
+   * resourcesFromBundleDeploymentStatus extracts the list of resources deployed by a BundleDeployment
+   */
+  resourcesFromBundleDeploymentStatus(status: BundleDeploymentStatus): Resource[] {
+    // status.resources includes of resources that were deployed by Fleet *and still exist in the cluster*
+    // Use a map to avoid `find` over and over again
+    const resources = (status?.resources || []).reduce((res, r) => {
+      res[resourceKey(r)] = Object.assign({ state: STATES_ENUM.READY }, r);
+
+      return res;
+    }, {} as { [resourceKey: string]: Resource });
+
+    const modified: Resource[] = [];
+
+    for (const r of status?.modifiedStatus || []) {
+      const state = r.missing ? STATES_ENUM.MISSING : r.delete ? STATES_ENUM.ORPHANED : STATES_ENUM.MODIFIED;
+      const found: Resource = resources[resourceKey(r)];
+
+      // Depending on the state, the same resource can appear in both fields
+      if (found) {
+        found.state = state;
+      } else {
+        modified.push(Object.assign({ state }, r));
+      }
+    }
+    for (const r of status?.nonReadyStatus || []) {
+      const state = r.summary?.state || STATES_ENUM.UNKNOWN;
+      const found: Resource = resources[resourceKey(r)];
+
+      if (found) {
+        found.state = state;
+      }
+    }
+
+    return modified.concat(Object.values(resources));
+  }
+
+  /**
+   * resourcesFromBundleStatus extracts the list of resources deployed by a Bundle
+   */
+  resourcesFromBundleStatus(status: BundleStatus): Resource[] {
+    // The state of every resource is spread all over the bundle status.
+    // resourceKey contains one entry per resource AND cluster (built by Fleet from all the child BundleDeployments).
+    // However, those entries do not contain the cluster that they belong to, leading to duplicate entries
+
+    // 1. Fold resourceKey by using a unique key, initializing counters for multiple occurrences of the same resource
+    const resources = (status.resourceKey || []).reduce((res, r) => {
+      const k = resourceKey(r);
+
+      if (!res[k]) {
+        res[k] = { r, count: {} };
+      }
+      incr(res[k].count, STATES_ENUM.READY);
+
+      return res;
+    }, {} as { [resourceKey: string]: { r: BundleResourceKey, count: StatesCounter } });
+
+    // 2. Non-ready resources are counted differently and may also appear in resourceKey, depending on their state
+    for (const bundle of status.summary?.nonReadyResources || []) {
+      for (const r of bundle.modifiedStatus || []) {
+        const k = resourceKey(r);
+
+        if (!resources[k]) {
+          resources[k] = { r, count: {} };
+        }
+
+        if (r.missing) {
+          incr(resources[k].count, STATES_ENUM.MISSING);
+        } else if (r.delete) {
+          resources[k].count[STATES_ENUM.READY]--;
+          incr(resources[k].count, STATES_ENUM.ORPHANED);
+        } else {
+          resources[k].count[STATES_ENUM.READY]--;
+          incr(resources[k].count, STATES_ENUM.MODIFIED);
+        }
+      }
+      for (const r of bundle.nonReadyStatus || []) {
+        const k = resourceKey(r);
+        const state = r.summary?.state || STATES_ENUM.UNKNOWN;
+
+        resources[k].count[STATES_ENUM.READY]--;
+        incr(resources[k].count, state);
+      }
+    }
+
+    // 3. Unfold back to an array of resources for display
+    return Object.values(resources).reduce((res, e) => {
+      const { r, count } = e;
+
+      for (const state in count) {
+        for (let x = 0; x < count[state]; x++) {
+          res.push(Object.assign({ state }, r));
+        }
+      }
+
+      return res;
+    }, [] as Resource[]);
+  }
+
+  clusterIdFromBundleDeploymentLabels(labels?: Labels): string {
+    const clusterNamespace = labels?.[FLEET_ANNOTATIONS.CLUSTER_NAMESPACE];
+    const clusterName = labels?.[FLEET_ANNOTATIONS.CLUSTER];
+
+    return `${ clusterNamespace }/${ clusterName }`;
+  }
+}
+
+const instance = new Fleet();
+
+export default instance;

package/utils/string.js

@@ -321,3 +321,12 @@ export function sanitizeValue(v) {
 export function sanitizeIP(v) {
   return (v || '').replace(/[^a-z0-9.:_-]/ig, '');
 }
+
+/**
+ * Return the string `<x> / <y>`
+ *
+ * Each param should be a number, otherwise `?` is used
+ */
+export function xOfy(x, y) {
+  return `${ typeof x === 'number' ? x : '?' }/${ typeof y === 'number' ? y : '?' }`;
+}

package/utils/v-sphere.ts

@@ -0,0 +1,282 @@
+import merge from 'lodash/merge';
+import { SECRET } from '@shell/config/types';
+import { PROVISIONING_PRE_BOOTSTRAP } from '@shell/store/features';
+
+export const VMWARE_VSPHERE = 'vmwarevsphere';
+
+type Rke2Component = {
+    versionInfo: any;
+    userChartValues: any;
+    chartVersionKey: (chartName: string) => string;
+    value: any;
+    isEdit: boolean;
+    provider: string;
+    $store: any,
+}
+
+type SecretDetails = {
+  generateName: string,
+  upstreamClusterName: string,
+  upstreamNamespace: string,
+  downstreamName: string,
+  downstreamNamespace: string,
+  json?: object,
+}
+type Values = any;
+
+type ChartValues = {
+    defaultValues: Values,
+    userValues: Values,
+    combined: Values,
+};
+
+const rootGenerateName = 'vsphere-secret-';
+
+type SecretJson = any;
+
+class VSphereUtils {
+  private async findSecret(
+    { $store }: Rke2Component, {
+      generateName, upstreamClusterName, upstreamNamespace, downstreamName, downstreamNamespace
+    }: SecretDetails): Promise<SecretJson | undefined> {
+    const secrets = await $store.dispatch('management/request', { url: `/v1/${ SECRET }/${ upstreamNamespace }?filter=metadata.name=${ generateName }` });
+
+    const applicableSecret = secrets.data?.filter((s: any) => {
+      return s.metadata.annotations['provisioning.cattle.io/sync-target-namespace'] === downstreamNamespace &&
+        s.metadata.annotations['provisioning.cattle.io/sync-target-name'] === downstreamName &&
+        s.metadata.annotations['rke.cattle.io/object-authorized-for-clusters'].includes(upstreamClusterName);
+    });
+
+    if (applicableSecret.length > 1) {
+      return Promise.reject(new Error(`Found multiple matching secrets (${ upstreamNamespace }/${ upstreamNamespace } for ${ upstreamClusterName }), this will cause synchronizing mishaps. Consider removing stale secrets from old clusters`));
+    }
+
+    return applicableSecret[0];
+  }
+
+  private async findOrCreateSecret(
+    rke2Component: Rke2Component,
+    {
+      generateName, upstreamClusterName, upstreamNamespace, downstreamName, downstreamNamespace, json
+    }: SecretDetails
+  ) {
+    const { $store } = rke2Component;
+
+    const secretJson = await this.findSecret(rke2Component, {
+      generateName,
+      upstreamClusterName,
+      upstreamNamespace,
+      downstreamName,
+      downstreamNamespace
+    }) || json;
+
+    return await $store.dispatch('management/create', secretJson);
+  }
+
+  private findChartValues({
+    versionInfo,
+    userChartValues,
+    chartVersionKey,
+  }: Rke2Component, chartName: string): ChartValues | undefined {
+    const chartValues = versionInfo[chartName]?.values;
+
+    if (!chartValues) {
+      return;
+    }
+    const userValues = userChartValues[chartVersionKey(chartName)];
+
+    return {
+      defaultValues: chartValues,
+      userValues,
+      combined:      merge({}, chartValues || {}, userValues || {})
+    };
+  }
+
+  /**
+   * Check that system is setup to handle vsphere secrets syncing downstream
+   *
+   * Do this via checking the provider and that the required FF is enabled.
+   */
+  private handleVsphereSecret({ $store, provider }: { $store: any, provider: string}): boolean {
+    if (provider !== VMWARE_VSPHERE) {
+      return false;
+    }
+
+    const isPrebootstrapEnabled = $store.getters['features/get'](PROVISIONING_PRE_BOOTSTRAP);
+
+    if (!isPrebootstrapEnabled) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+    * Create upstream vsphere cpi secret to sync downstream
+    */
+  async handleVsphereCpiSecret(rke2Component: Rke2Component) {
+    if (!this.handleVsphereSecret(rke2Component)) {
+      return;
+    }
+
+    const generateName = `${ rootGenerateName }cpi-`;
+    const downstreamName = 'rancher-vsphere-cpi-credentials';
+    const downstreamNamespace = 'kube-system';
+    const { value } = rke2Component;
+
+    // check values for cpi chart has 'use our method' checkbox
+    const { userValues, combined } = this.findChartValues(rke2Component, 'rancher-vsphere-cpi') || {};
+
+    if (!combined?.vCenter?.credentialsSecret?.generate) {
+      if (userValues?.vCenter?.username) {
+        userValues.vCenter.username = '';
+      }
+      if (userValues?.vCenter?.password) {
+        userValues.vCenter.password = '';
+      }
+
+      return;
+    }
+
+    // find values needed in cpi chart value - https://github.com/rancher/vsphere-charts/blob/main/charts/rancher-vsphere-cpi/questions.yaml#L16-L42
+    const { username, password, host } = combined.vCenter;
+
+    if (!username || !password || !host) {
+      throw new Error('vSphere CPI username, password and host are all required when generating a new secret');
+    }
+
+    // create secret as per https://github.com/rancher/vsphere-charts/blob/main/charts/rancher-vsphere-cpi/templates/secret.yaml
+    const upstreamClusterName = value.metadata.name;
+    const upstreamNamespace = value.metadata.namespace;
+    const secret = await this.findOrCreateSecret(rke2Component, {
+      generateName,
+      upstreamClusterName,
+      upstreamNamespace,
+      downstreamName,
+      downstreamNamespace,
+      json: {
+        type:     SECRET,
+        metadata: {
+          namespace: upstreamNamespace,
+          generateName,
+          labels:    {
+            'vsphere-cpi-infra': 'secret',
+            component:           'rancher-vsphere-cpi-cloud-controller-manager'
+          },
+          annotations: {
+            'provisioning.cattle.io/sync-target-namespace': downstreamNamespace,
+            'provisioning.cattle.io/sync-target-name':      downstreamName,
+            'rke.cattle.io/object-authorized-for-clusters': upstreamClusterName,
+            'provisioning.cattle.io/sync-bootstrap':        'true'
+          }
+        },
+      }
+    });
+
+    secret.setData(`${ host }.username`, username);
+    secret.setData(`${ host }.password`, password);
+
+    await secret.save();
+
+    // reset cpi chart values
+    if (!userValues.vCenter.credentialsSecret) {
+      userValues.vCenter.credentialsSecret = {};
+    }
+    userValues.vCenter.credentialsSecret.generate = false;
+    userValues.vCenter.credentialsSecret.name = downstreamName;
+    userValues.vCenter.username = '';
+    userValues.vCenter.password = '';
+  }
+
+  /**
+    * Create upstream vsphere csi secret to sync downstream
+    */
+  async handleVsphereCsiSecret(rke2Component: Rke2Component) {
+    if (!this.handleVsphereSecret(rke2Component)) {
+      return;
+    }
+
+    const generateName = `${ rootGenerateName }csi-`;
+    const downstreamName = 'rancher-vsphere-csi-credentials';
+    const downstreamNamespace = 'kube-system';
+    const { value } = rke2Component;
+
+    // check values for cpi chart has 'use our method' checkbox
+    const { userValues, combined } = this.findChartValues(rke2Component, 'rancher-vsphere-csi') || {};
+
+    if (!combined?.vCenter?.configSecret?.generate) {
+      if (userValues?.vCenter?.username) {
+        userValues.vCenter.username = '';
+      }
+      if (userValues?.vCenter?.password) {
+        userValues.vCenter.password = '';
+      }
+
+      return;
+    }
+
+    // find values needed in cpi chart value - https://github.com/rancher/vsphere-charts/blob/main/charts/rancher-vsphere-csi/questions.yaml#L1-L36
+    const {
+      username, password, host, datacenters, port, insecureFlag
+    } = combined.vCenter;
+
+    if (!username || !password || !host || !datacenters) {
+      throw new Error('vSphere CSI username, password, host and datacenters are all required when generating a new secret');
+    }
+
+    // This is a copy of https://github.com/rancher/vsphere-charts/blob/a5c99d716df960dc50cf417d9ecffad6b55ca0ad/charts/rancher-vsphere-csi/values.yaml#L12-L21
+    // Which makes it's way into the secret via https://github.com/rancher/vsphere-charts/blob/main/charts/rancher-vsphere-csi/templates/secret.yaml#L8
+    let configTemplateString = '      [Global]\n      cluster-id = {{ required \".Values.vCenter.clusterId must be provided\" (default .Values.vCenter.clusterId .Values.global.cattle.clusterId) | quote }}\n      user = {{ .Values.vCenter.username | quote }}\n      password = {{ .Values.vCenter.password | quote }}\n      port = {{ .Values.vCenter.port | quote }}\n      insecure-flag = {{ .Values.vCenter.insecureFlag | quote }}\n\n      [VirtualCenter {{ .Values.vCenter.host | quote }}]\n      datacenters = {{ .Values.vCenter.datacenters | quote }}';
+
+    configTemplateString = configTemplateString.replace('{{ required \".Values.vCenter.clusterId must be provided\" (default .Values.vCenter.clusterId .Values.global.cattle.clusterId) | quote }}', `"{{clusterId}}"`);
+    configTemplateString = configTemplateString.replace('{{ .Values.vCenter.username | quote }}', `"${ username }"`);
+    configTemplateString = configTemplateString.replace('{{ .Values.vCenter.password | quote }}', `"${ password }"`);
+    configTemplateString = configTemplateString.replace('{{ .Values.vCenter.port | quote }}', `"${ port }"`);
+    configTemplateString = configTemplateString.replace('{{ .Values.vCenter.insecureFlag | quote }}', `"${ insecureFlag }"`);
+    configTemplateString = configTemplateString.replace('{{ .Values.vCenter.host | quote }}', `"${ host }"`);
+    configTemplateString = configTemplateString.replace('{{ .Values.vCenter.datacenters | quote }}', `"${ datacenters }"`);
+    // create secret as per https://github.com/rancher/vsphere-charts/blob/main/charts/rancher-vsphere-csi/templates/secret.yaml
+    const upstreamClusterName = value.metadata.name;
+    const upstreamNamespace = value.metadata.namespace;
+
+    const secret = await this.findOrCreateSecret(rke2Component, {
+      generateName,
+      upstreamClusterName,
+      upstreamNamespace,
+      downstreamName,
+      downstreamNamespace,
+      json: {
+        type:     SECRET,
+        metadata: {
+          namespace:   upstreamNamespace,
+          generateName,
+          annotations: {
+            'provisioning.cattle.io/sync-target-namespace': downstreamNamespace,
+            'provisioning.cattle.io/sync-target-name':      downstreamName,
+            'rke.cattle.io/object-authorized-for-clusters': upstreamClusterName,
+            'provisioning.cattle.io/sync-bootstrap':        'true'
+          }
+        },
+      }
+    });
+
+    secret.setData(`csi-vsphere.conf`, configTemplateString);
+
+    await secret.save();
+
+    // reset csi chart values
+    if (!userValues.vCenter.configSecret) {
+      userValues.vCenter.configSecret = {};
+    }
+    userValues.vCenter.configSecret.generate = false;
+    userValues.vCenter.configSecret.name = downstreamName;
+    userValues.vCenter.username = '';
+    userValues.vCenter.password = '';
+    userValues.vCenter.host = '';
+    userValues.vCenter.datacenters = '';
+  }
+}
+
+const utils = new VSphereUtils();
+
+export default utils;

package/vue.config.js

@@ -120,11 +120,11 @@ const getLoaders = (SHELL_ABS) => {
   }
 
   return [
-    // Ensure there is a fallback for browsers that don't support web workers
+    // no fallback for pre-2013 browsers https://caniuse.com/webworkers
     {
       test:    /web-worker.[a-z-]+.js/i,
       loader:  'worker-loader',
-      options: { inline: 'fallback' },
+      options: { inline: 'no-fallback' },
     },
     // Handler for csv files (e.g. ec2 instance data)
     {
@@ -512,7 +512,7 @@ module.exports = function(dir, _appConfig) {
       config.resolve.alias['@pkg'] = path.join(dir, 'pkg');
       config.resolve.alias['./node_modules'] = path.join(dir, 'node_modules');
       config.resolve.alias['@components'] = COMPONENTS_DIR;
-      config.resolve.alias['vue$'] = path.resolve(process.cwd(), 'node_modules', 'vue', 'dist', dev ? 'vue.js' : 'vue.min.js');
+      config.resolve.alias['vue$'] = path.resolve(process.cwd(), 'node_modules', 'vue', 'dist', 'vue.js');
       config.resolve.modules.push(__dirname);
       config.plugins.push(getVirtualModules(dir, includePkg));
       config.plugins.push(getAutoImport());

package/shell/types/shell/index.d.ts

@@ -1,2 +0,0 @@
-// Auto-generated type definitions for shell
-// Do not modify this file as changes will get overwritten