@rancher/shell 2.0.2 → 2.0.3

package/scripts/publish-shell.sh

@@ -64,6 +64,13 @@ function publish() {
     PUBLISH_ARGS="$PUBLISH_ARGS --tag legacy-v2"
   fi
 
+  # when testing the workflow, we don't want to actually do an npm publish but only a dry run
+  if [ ${DRY_RUN} == "true" ]; then
+    PUBLISH_ARGS="$PUBLISH_ARGS --dry-run"
+  fi
+
+  echo "Publish to NPM - arguments ::: ${PUBLISH_ARGS}"
+
   # Make a note of dependency versions, if required
   node ${SCRIPT_DIR}/record-deps.js
 

package/scripts/typegen.sh

@@ -31,9 +31,11 @@ ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/plugins/dashboard-store/normalize
 ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/plugins/dashboard-store/resource-class.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/plugins/dashboard-store/ > /dev/null
 ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/plugins/dashboard-store/classify.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/plugins/dashboard-store/ > /dev/null
 ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/plugins/dashboard-store/actions.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/plugins/dashboard-store/ > /dev/null
+${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/plugins/steve/steve-class.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/plugins/steve/ > /dev/null
 
 # # mixins
 ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/mixins/create-edit-view/index.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/mixins/create-edit-view > /dev/null
+${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/mixins/resource-fetch.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/mixins > /dev/null
 
 # # models
 ${BASE_DIR}/node_modules/.bin/tsc ${SHELL_DIR}/models/namespace.js --declaration --allowJs --emitDeclarationOnly --outDir ${SHELL_DIR}/tmp/models/ > /dev/null
@@ -93,4 +95,4 @@ function processDir() {
 
 processDir ${SHELL_DIR}/tmp @shell
 
-rm -rf ${SHELL_DIR}/tmp
+rm -rf ${SHELL_DIR}/tmp

package/store/features.js

@@ -35,6 +35,7 @@ export const HARVESTER_CONTAINER = create('harvester-baremetal-container-workloa
 export const FLEET_WORKSPACE_BACK = create('provisioningv2-fleet-workspace-back-population', false);
 export const STEVE_CACHE = create('ui-sql-cache', false);
 export const UIEXTENSION = create('uiextension', true);
+export const PROVISIONING_PRE_BOOTSTRAP = create('provisioningprebootstrap', false);
 
 // Not currently used.. no point defining ones we don't use
 // export const EMBEDDED_CLUSTER_API = create('embedded-cluster-api', true);

package/types/resources/fleet.d.ts

@@ -0,0 +1,40 @@
+export interface BundleResourceKey {
+  kind: string,
+  apiVersion: string,
+  namespace?: string,
+  name: string,
+}
+
+export interface BundleDeploymentResource extends BundleResourceKey {
+  createdAt?: string,
+}
+
+export interface BundleModifiedResource extends BundleResourceKey {
+  missing?: boolean,
+  delete?: boolean,
+  patch: string,
+}
+
+export interface BundleNonReadyResource extends BundleResourceKey {
+  summary: { [state: string]: string }
+}
+
+export interface BundleNonReadyBundle {
+  modifiedStatus: BundleModifiedResource[],
+  nonReadyStatus: BundleNonReadyResource[],
+}
+
+export interface BundleDeploymentStatus {
+  resources?: BundleDeploymentResource[],
+  modifiedStatus?: BundleModifiedResource[],
+  nonReadyStatus?: BundleNonReadyResource[],
+}
+
+export interface BundleStatusSummary {
+  nonReadyResources?: BundleNonReadyBundle[],
+}
+
+export interface BundleStatus {
+  resourceKey?: BundleResourceKey[],
+  summary?: BundleStatusSummary,
+}

package/types/shell/index.d.ts

@@ -125,6 +125,8 @@ export namespace FLEET {
     export const BUNDLE_ID: string;
     const MANAGED_1: string;
     export { MANAGED_1 as MANAGED };
+    const CLUSTER_NAMESPACE_1: string;
+    export { CLUSTER_NAMESPACE_1 as CLUSTER_NAMESPACE };
     export const CLUSTER: string;
 }
 export namespace RBAC {
@@ -2328,6 +2330,66 @@ declare var _default: import("vue").DefineComponent<{
 export default _default;
 }
 
+// @shell/mixins/resource-fetch
+
+declare module '@shell/mixins/resource-fetch' {
+declare namespace _default {
+    const mixins: any[];
+    function data(): {
+        perfConfig: {};
+        init: boolean;
+        multipleResources: any[];
+        loadResources: any[];
+        hasManualRefresh: boolean;
+        watch: boolean;
+        isTooManyItemsToAutoUpdate: boolean;
+        force: boolean;
+        incremental: boolean;
+        fetchedResourceType: any[];
+        paginating: any;
+    };
+    function data(): {
+        perfConfig: {};
+        init: boolean;
+        multipleResources: any[];
+        loadResources: any[];
+        hasManualRefresh: boolean;
+        watch: boolean;
+        isTooManyItemsToAutoUpdate: boolean;
+        force: boolean;
+        incremental: boolean;
+        fetchedResourceType: any[];
+        paginating: any;
+    };
+    function beforeDestroy(): void;
+    function beforeDestroy(): void;
+    namespace computed {
+        function rows(): any;
+        function rows(): any;
+        function loading(): any;
+        function loading(): any;
+        const refreshFlag: import("vuex").Computed;
+    }
+    namespace watch {
+        function refreshFlag(neu: any): Promise<void>;
+        function refreshFlag(neu: any): Promise<void>;
+    }
+    namespace methods {
+        function $initializeFetchData(type: any, multipleResources: any[], storeType: any): void;
+        function $initializeFetchData(type: any, multipleResources: any[], storeType: any): void;
+        function $fetchType(type: any, multipleResources: any[], storeType: any): any;
+        function $fetchType(type: any, multipleResources: any[], storeType: any): any;
+        function __getCountForResources(resourceNames: any, namespace: any, storeType: any): any;
+        function __getCountForResources(resourceNames: any, namespace: any, storeType: any): any;
+        function __getCountForResource(resourceName: any, namespace: any, storeType: any): any;
+        function __getCountForResource(resourceName: any, namespace: any, storeType: any): any;
+        function __gatherResourceFetchData(resourceName: any, multipleResources: any, currStore: any): void;
+        function __gatherResourceFetchData(resourceName: any, multipleResources: any, currStore: any): void;
+    }
+}
+export default _default;
+}
+
 // @shell/models/namespace
 
 declare module '@shell/models/namespace' {
@@ -3084,6 +3146,40 @@ export default class Resource {
 }
 }
 
+// @shell/plugins/steve/hybrid-class
+
+declare module '@shell/plugins/steve/hybrid-class' {
+export function cleanHybridResources(data: any): any;
+export default class HybridModel {
+    constructor(data: any, ctx: any, rehydrateNamespace?: any, setClone?: boolean);
+    get labels(): any;
+    setLabels(val: any): void;
+    metadata: {};
+    setLabel(key: any, val: any): void;
+    get annotations(): any;
+    setAnnotations(val: any): void;
+    setAnnotation(key: any, val: any): void;
+    get state(): any;
+}
+}
+
+// @shell/plugins/steve/steve-class
+
+declare module '@shell/plugins/steve/steve-class' {
+export default class SteveModel extends HybridModel {
+    get name(): any;
+    get namespace(): any;
+    /**
+     * Set description based on the type of model available with private fallback
+     */
+    set description(arg: any);
+    get description(): any;
+    _description: any;
+    cleanForSave(data: any, forNew: any): any;
+}
+import HybridModel from "./hybrid-class";
+}
+
 // @shell/store/features
 
 declare module '@shell/store/features' {
@@ -3103,6 +3199,7 @@ export const HARVESTER_CONTAINER: any;
 export const FLEET_WORKSPACE_BACK: any;
 export const STEVE_CACHE: any;
 export const UIEXTENSION: any;
+export const PROVISIONING_PRE_BOOTSTRAP: any;
 export namespace getters {
     function get(state: any, getters: any, rootState: any, rootGetters: any): (name: any) => any;
 }

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/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/v-sphere.ts

@@ -1,5 +1,8 @@
 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;
@@ -7,6 +10,7 @@ type Rke2Component = {
     chartVersionKey: (chartName: string) => string;
     value: any;
     isEdit: boolean;
+    provider: string;
     $store: any,
 }
 
@@ -88,10 +92,33 @@ class VSphereUtils {
     };
   }
 
+  /**
+   * 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';
@@ -165,6 +192,10 @@ class VSphereUtils {
     * 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';

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());