@rancher/shell 3.0.8-rc.9 → 3.0.8

package/plugins/steve/steve-pagination-utils.ts

@@ -37,20 +37,35 @@ interface Namespace extends ModelNamespace {
   }
 }
 
+interface NamespaceProjectFilterResult {
+  /**
+   * True if the ns should be filtered IN. False if filtered OUT.
+   */
+  [nsName: string]: boolean;
+}
+
+/**
+ * Helper class, contains namespace / project filter specific functions
+ */
 class NamespaceProjectFilters {
   /**
    * User needs all resources.... except if there's some settings which should remove resources in specific circumstances
    */
   protected handlePrefAndSettingFilter(args: {
     allNamespaces: Namespace[],
+    /**
+     * Reserved / Obscure namespaces are ones used to support clusters and users. By default these are hidden
+     */
     showReservedRancherNamespaces: boolean,
+    /**
+     * Has product config disabled system projects and namespaces
+     */
     productHidesSystemNamespaces: boolean,
-  }): PaginationParamFilter[] {
+  }): NamespaceProjectFilterResult {
     const { allNamespaces, showReservedRancherNamespaces, productHidesSystemNamespaces } = args;
 
-    // These are AND'd together
     // Not ns 1 AND ns 2
-    const filterNamespaces = allNamespaces.reduce((res, ns) => {
+    return allNamespaces.reduce((res, ns) => {
       // Links to ns.isObscure and covers things like `c-`, `user-`, etc (see OBSCURE_NAMESPACE_PREFIX)
       const hideObscure = showReservedRancherNamespaces ? false : ns.isObscure;
 
@@ -58,23 +73,11 @@ class NamespaceProjectFilters {
       const hideSystem = productHidesSystemNamespaces ? ns.isSystem : false;
 
       if (hideObscure || hideSystem) {
-        res.push(ns.name);
+        res[ns.name] = false;
       }
 
       return res;
-    }, [] as String[]);
-
-    if (filterNamespaces.length) {
-      return [new PaginationParamFilter({
-        fields: [{
-          value:    filterNamespaces.join(','),
-          equality: PaginationFilterEquality.NOT_IN,
-          field:    'metadata.namespace',
-        }],
-      })];
-    }
-
-    return [];
+    }, {} as NamespaceProjectFilterResult);
   }
 
   /**
@@ -88,31 +91,88 @@ class NamespaceProjectFilters {
     allNamespaces: Namespace[],
     isAllSystem: boolean,
     isAllUser: boolean,
-  }) {
-    const { allNamespaces, isAllSystem } = args;
+  }): NamespaceProjectFilterResult {
+    const { allNamespaces, isAllSystem, isAllUser } = args;
     const allSystem = allNamespaces.filter((ns) => ns.isSystem);
 
-    // > Neither of these use projectsOrNamespaces to avoid scenarios where the local cluster provides a namespace which has
-    // > a matching project... which could lead to results in the user project resource being included in the system filter
-    if (isAllSystem) {
-      // return resources in system ns 1 OR in system ns 2 ...
-      // &filter=metadata.namespace=system ns 1,metadata.namespace=system ns 2
-      return [PaginationParamFilter.createMultipleFields(
-        allSystem.map(
-          (ns) => new PaginationFilterField({ field: 'metadata.namespace', value: ns.name })
-        )
-      )];
-    } else { // if isAllUser
-      // return resources not in system ns 1 AND not in system ns 2 ...
-      // &filter=metadata.namespace!=system ns 1&filter=metadata.namespace!=system ns 2
-      return allSystem.map((ns) => PaginationParamFilter.createSingleField({
-        field: 'metadata.namespace', value: ns.name, equals: false
+    return allSystem.reduce((res, ns) => {
+      if (isAllSystem) {
+        // We want to filter IN system namespaces
+        res[ns.name] = true;
+      }
+
+      if (isAllUser) {
+        // We want to filter OUT system namespaces
+        res[ns.name] = false;
+      }
+
+      return res;
+    }, {} as NamespaceProjectFilterResult);
+  }
+
+  /**
+   * Combine result `b` into `a` and return result
+   */
+  protected combineNsProjectFilterResults(a: NamespaceProjectFilterResult, b: NamespaceProjectFilterResult): NamespaceProjectFilterResult {
+    // Start with `a`
+    const res = { ...a };
+
+    // Merge entries from `b` into `a` if they don't exist in `a`. This maintains a hierarchy
+    // 1. if something has been excluded in `a` ignore requests to include given `b`
+    // 2. if something has been included in `a` ignore requests to exclude given `b`
+    Object.entries(b).forEach(([ns, include]) => {
+      if (res[ns] === undefined) {
+        res[ns] = include;
+      }
+    });
+
+    return res;
+  }
+
+  /**
+   * Convert @NamespaceProjectFilterResult into @PaginationParamFilter
+   */
+  protected createFiltersFromNamespaceProjectFilterResult(filterResult: NamespaceProjectFilterResult): PaginationParamFilter[] {
+    const inList: string[] = [];
+    const outList: string[] = [];
+
+    Object.entries(filterResult).forEach(([ns, include]) => {
+      if (include) {
+        inList.push(ns);
+      } else {
+        outList.push(ns);
+      }
+    });
+
+    const res: PaginationParamFilter[] = [];
+
+    // There's no point having both IN and OUT lists together, so prefer the IN list
+    if (inList.length) {
+      res.push(new PaginationParamFilter({
+        fields: [{
+          value:    inList.join(','),
+          equality: PaginationFilterEquality.IN,
+          field:    'metadata.namespace',
+        }],
+      }));
+    } else if (outList.length) {
+      res.push(new PaginationParamFilter({
+        fields: [{
+          value:    outList.join(','),
+          equality: PaginationFilterEquality.NOT_IN,
+          field:    'metadata.namespace',
+        }],
       }));
     }
+
+    return res;
   }
 
   /**
    * User needs resources in a set of projects or namespaces
+   *
+   * Mainly deals with the projectornamespaces filter, also ensures namespace in local cluster matching target project's aren't included
+   *
    */
   protected handleSelectionFilter(neu: string[], isLocalCluster: boolean) {
     // User has one or more projects or namespaces. We can pass this straight through to projectsornamespaces
@@ -124,12 +184,12 @@ class NamespaceProjectFilters {
     ];
 
     if (isLocalCluster) {
-      // > As per `handleSystemOrUserFilter` above, we need to be careful of the local cluster where there's namespaces related to projects with the same id
-      // > In this case
+      // We need to be careful of the local cluster where there's namespaces related to projects with the same id
+      // In this case
       // - We're including resources in the project and it's related namespace (via projectsornamespaces)
       // - We're also then excluding resources in the related namespace (via below `filter`)
 
-      // Exclude resources NOT in projects namespace 1 AND not in projects namespace 2
+      // Exclude resources NOT in project's backing namespace 1 AND not in project's backing namespace 2
       // &filter=metadata.namespace!=pn1&filter=metadata.namespace!=pn2
       return {
         projectsOrNamespaces,
@@ -352,24 +412,29 @@ class StevePaginationUtils extends NamespaceProjectFilters {
     let projectsOrNamespaces: PaginationParamProjectOrNamespace[] = [];
     // used to return resources in / not in namespaces
     // &filter=metadata.namespace=abc
-    let filters: PaginationParamFilter[] = [];
+    const filters: PaginationParamFilter[] = [];
+    let nsProjectFilterResults = {};
 
     if (!showReservedRancherNamespaces || productHidesSystemNamespaces) {
-      // We need to hide reserved namespaces ('c-', 'user-', etc) OR system namespaces
-      filters = this.handlePrefAndSettingFilter({
+      // We need to hide reserved namespaces ('c-', 'user-', etc) OR system namespaces (given product may hide them)
+      nsProjectFilterResults = this.combineNsProjectFilterResults(nsProjectFilterResults, this.handlePrefAndSettingFilter({
         allNamespaces, showReservedRancherNamespaces, productHidesSystemNamespaces
-      });
+      }));
     }
 
     const isAllSystem = selection[0] === NAMESPACE_FILTER_ALL_SYSTEM;
     const isAllUser = selection[0] === NAMESPACE_FILTER_ALL_USER;
 
     if (selection.length === 1 && (isAllSystem || isAllUser)) {
-      // Filter by resources either in or not in system namespaces
-      filters.push(...this.handleSystemOrUserFilter({
+      // Filter by resources either in or not in system namespaces (given user selection)
+      nsProjectFilterResults = this.combineNsProjectFilterResults(nsProjectFilterResults, this.handleSystemOrUserFilter({
         allNamespaces, isAllSystem, isAllUser
       }));
+
+      filters.push(...this.createFiltersFromNamespaceProjectFilterResult(nsProjectFilterResults));
     } else {
+      filters.push(...this.createFiltersFromNamespaceProjectFilterResult(nsProjectFilterResults));
+
       // User has one or more projects or namespaces
       const res = this.handleSelectionFilter(selection, isLocalCluster);
 

package/rancher-components/Form/Checkbox/Checkbox.vue

@@ -269,7 +269,7 @@ export default defineComponent({
     class="checkbox-outer-container"
     data-checkbox-ctrl
     :class="{
-      'v-popper--has-tooltip': hasTooltip,
+      'has-clean-tooltip': hasTooltip,
     }"
   >
     <label

package/rancher-components/Form/LabeledInput/LabeledInput.vue

@@ -355,7 +355,7 @@ export default defineComponent({
       disabled: isDisabled,
       [status]: status,
       suffix: hasSuffix,
-      'v-popper--has-tooltip': hasTooltip,
+      'has-clean-tooltip': hasTooltip,
       'compact-input': isCompact,
       hideArrows,
       [className]: true

package/rancher-components/RcDropdown/useDropdownContext.ts

@@ -1,9 +1,7 @@
-import { ref, provide, nextTick, defineEmits } from 'vue';
+import { ref, provide, nextTick, EmitFn } from 'vue';
 import { useDropdownCollection } from './useDropdownCollection';
 import { RcButtonType } from '@components/RcButton';
 
-const rcDropdownEmits = defineEmits(['update:open']);
-
 /**
  * Composable that provides the context for a dropdown menu. Includes methods
  * and state for managing the dropdown's visibility, focus, and keyboard
@@ -13,7 +11,7 @@ const rcDropdownEmits = defineEmits(['update:open']);
  * @returns Dropdown context methods and state. Used for programmatic
  * interactions and setting focus.
  */
-export const useDropdownContext = (emit: typeof rcDropdownEmits) => {
+export const useDropdownContext = (emit: EmitFn<['update:open']>) => {
   const {
     dropdownItems,
     firstDropdownItem,

package/rancher-components/RcItemCard/RcItemCard.vue

@@ -72,7 +72,7 @@ interface RcItemCardProps {
   id: string;
 
   /** Any object value associated with this card */
-  value: ItemValue;
+  value?: ItemValue;
 
   /** Card title, status icons and action menu. Image will be included in the header in small variant too */
   header: Header;

package/scripts/publish-shell.sh

@@ -8,6 +8,7 @@ SHELL_DIR=$BASE_DIR/shell/
 CREATORS_DIR=$BASE_DIR/creators/extension
 FORCE_PUBLISH_TO_NPM="false"
 DEFAULT_NPM_REGISTRY="https://registry.npmjs.org"
+DUMMY_VERSION="99.99.99"
 
 # if TAG doesn't exist, we can exit as it's needed for any type of publish.
 if [ -z "$TAG" ]; then
@@ -84,6 +85,14 @@ function publish() {
   fi
 }
 
+update_version_in_package_json() {
+  local package_json_path="$1"
+  local version="$2"
+
+  sed -i.bak -e "s/\"version\": \"[0-9]*.[0-9]*.[0-9]*\(-alpha\.[0-9]*\|-release[0-9]*.[0-9]*.[0-9]*\|-rc\.[0-9]*\)\{0,1\}\",/\"version\": \"${version}\",/g" "$package_json_path"
+  rm "${package_json_path}.bak"
+}
+
 echo "TAG ${TAG}"
   
   # let's get the package name and version from the tag
@@ -102,10 +111,26 @@ fi
 case $PKG_NAME in
   "shell")
     echo "Publishing only Shell pkg via tagged release"
+
+    # with the changes in https://github.com/rancher/dashboard/pull/16166/files#diff-d954ab41ef46f7fdbaaf6d8c2bc715ad2cc823a829317b6ff93a3c94a92811f1
+    #  with NPM 11.3 --dry--run now does additional checks, one of them is the version number
+    #  so for dry runs we need to provide a valid version number here (not something published before)
+    if [ ${DRY_RUN} == "true" ]; then
+      update_version_in_package_json "${SHELL_DIR}/package.json" "${DUMMY_VERSION}"
+    fi
+
     publish "Shell" ${SHELL_DIR} ${PKG_V}
     ;;
   "creators")
     echo "Publishing only Creators pkg via tagged release"
+
+    # with the changes in https://github.com/rancher/dashboard/pull/16166/files#diff-d954ab41ef46f7fdbaaf6d8c2bc715ad2cc823a829317b6ff93a3c94a92811f1
+    #  with NPM 11.3 --dry--run now does additional checks, one of them is the version number
+    #  so for dry runs we need to provide a valid version number here (not something published before)
+    if [ ${DRY_RUN} == "true" ]; then
+      update_version_in_package_json "${CREATORS_DIR}/package.json" "${DUMMY_VERSION}"
+    fi
+
     publish "Extension creator" ${CREATORS_DIR} ${PKG_V}
     ;;
   *)

package/store/__tests__/catalog.test.ts

@@ -88,7 +88,7 @@ describe('catalog', () => {
           }
         },
         state: {
-          $plugin:            { getDynamic: () => require(`@shell/models/chart`) },
+          $extension:         { getDynamic: () => require(`@shell/models/chart`) },
           [catalogStoreName]: { } as { [key: string]: any},
         },
         getters: {

package/store/__tests__/type-map.test.ts

@@ -1116,7 +1116,169 @@ describe('type-map', () => {
         });
       });
     });
+
+    describe('activeProducts', () => {
+      // Basic schemas for product filtering tests
+      const productSchemas = {
+        myType: {
+          id:     'mytype',
+          _id:    'mytype',
+          type:   SCHEMA,
+          _group: 'mygroup',
+        },
+        anotherType: {
+          id:     'anothertype',
+          _id:    'anothertype',
+          type:   SCHEMA,
+          _group: 'anothergroup',
+        },
+      };
+
+      const createProductState = (products) => ({
+        products,
+        schemaGeneration: 1,
+      });
+
+      const createProductRootGetters = (moduleSchemas = [], moduleName = 'cluster') => ({
+        'prefs/get':             () => false,
+        [`${ moduleName }/all`]: (resource) => {
+          if (resource === SCHEMA) {
+            return moduleSchemas;
+          }
+
+          return [];
+        },
+      });
+
+      describe('ifHaveType', () => {
+        it('should show product when matching type exists', () => {
+          const state = createProductState([{
+            name:       'test-product',
+            inStore:    'cluster',
+            ifHaveType: 'mytype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(1);
+          expect(active[0].name).toBe('test-product');
+        });
+
+        it('should hide product when matching type does not exist', () => {
+          const state = createProductState([{
+            name:       'test-product',
+            inStore:    'cluster',
+            ifHaveType: 'missingtype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+      });
+
+      describe('ifNotHaveType', () => {
+        it('should show product when matching type does NOT exist', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifNotHaveType: 'missingtype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(1);
+          expect(active[0].name).toBe('test-product');
+        });
+
+        it('should hide product when matching type exists', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifNotHaveType: 'mytype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+
+        it('should support regex pattern in ifNotHaveType', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifNotHaveType: 'my.*',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+
+        it('should show product when regex pattern does not match any type', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifNotHaveType: 'nomatch.*',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(1);
+          expect(active[0].name).toBe('test-product');
+        });
+      });
+
+      describe('combined ifHaveType and ifNotHaveType', () => {
+        it('should show product when ifHaveType matches and ifNotHaveType does not match', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifHaveType:    'mytype',
+            ifNotHaveType: 'missingtype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(1);
+          expect(active[0].name).toBe('test-product');
+        });
+
+        it('should hide product when ifHaveType matches but ifNotHaveType also matches', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifHaveType:    'mytype',
+            ifNotHaveType: 'anothertype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType, productSchemas.anotherType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+
+        it('should hide product when ifHaveType does not match', () => {
+          const state = createProductState([{
+            name:          'test-product',
+            inStore:       'cluster',
+            ifHaveType:    'missingtype',
+            ifNotHaveType: 'anothermissingtype',
+          }]);
+          const rootGetters = createProductRootGetters([productSchemas.myType]);
+
+          const active = getters.activeProducts(state, {}, {}, rootGetters);
+
+          expect(active).toHaveLength(0);
+        });
+      });
+    });
   });
 });
-
-// getTree - Remove ignored schemas, not-applicable to ns filter

package/store/auth.js

@@ -149,12 +149,16 @@ export const actions = {
       force = true;
     }
 
-    return dispatch('rancher/findAll', {
+    const providers = dispatch('rancher/findAll', {
       type: 'authProvider',
       opt:  {
-        url: `/v3-public/authProviders`, watch: false, force
+        url:   `/v1-public/authproviders`,
+        watch: false,
+        force
       }
     }, { root: true });
+
+    return providers;
   },
 
   getAuthConfigs({ dispatch }) {
@@ -349,13 +353,21 @@ export const actions = {
     const driver = await dispatch('getAuthProvider', provider);
 
     try {
-      const res = await driver.doAction('login', {
-        description:  'UI session',
-        responseType: 'cookie',
-        ...body
-      }, { redirectUnauthorized: false });
-
-      return res;
+      return await dispatch(
+        'management/request',
+        {
+          url:    `/v1-public/login`,
+          method: 'post',
+          data:   {
+            type:         driver.type,
+            description:  'UI session',
+            responseType: 'cookie',
+            ...body
+          },
+          redirectUnauthorized: false,
+        },
+        { root: true }
+      );
     } catch (err) {
       if (err._status === 401) {
         return Promise.reject(LOGIN_ERRORS.CLIENT_UNAUTHORIZED);
@@ -402,14 +414,14 @@ export const actions = {
     }
 
     // Unload plugins - we will load again on login
-    await rootState.$plugin.logout();
+    await rootState.$extension.logout();
 
     let logoutAction = '';
     const data = {};
 
     // SLO - Single-sign logout - will logout auth provider from all places where it's logged in
     if (options.slo) {
-      logoutAction = '?logoutAll';
+      logoutAction = '?all';
       data.finalRedirectUrl = returnTo({ isSlo: true }, this);
     }
 

package/store/i18n.js

@@ -285,8 +285,8 @@ export const actions = {
       return;
     }
 
-    const lastLoad = rootState.$plugin?.lastLoad;
-    const i18nExt = rootState.$plugin?.getDynamic('l10n', locale);
+    const lastLoad = rootState.$extension?.lastLoad;
+    const i18nExt = rootState.$extension?.getDynamic('l10n', locale);
     const reload = lastLoaded < lastLoad;
 
     lastLoaded = lastLoad;
@@ -314,7 +314,7 @@ export const actions = {
 
         // load all of the default locales from the plugins for fallback
         if (locale !== DEFAULT_LOCALE) {
-          const defaultI18nExt = rootState.$plugin?.getDynamic('l10n', DEFAULT_LOCALE);
+          const defaultI18nExt = rootState.$extension?.getDynamic('l10n', DEFAULT_LOCALE);
 
           if (defaultI18nExt && defaultI18nExt.length) {
             defaultI18nExt.forEach((fn) => {

package/store/index.js

@@ -233,7 +233,7 @@ const updateActiveNamespaceCache = (state, activeNamespaceCache) => {
  * Are we in the vai enabled world where mgmt clusters are paginated?
  */
 const paginateClusters = ({ rootGetters, state }) => {
-  return paginationUtils.isEnabled({ rootGetters, $plugin: state.$plugin }, { store: 'management', resource: { id: MANAGEMENT.CLUSTER, context: 'side-bar' } });
+  return paginationUtils.isEnabled({ rootGetters, $extension: state.$extension }, { store: 'management', resource: { id: MANAGEMENT.CLUSTER, context: 'side-bar' } });
 };
 
 export const state = () => {
@@ -262,6 +262,7 @@ export const state = () => {
     $router:                 markRaw({}),
     $route:                  markRaw({}),
     $plugin:                 markRaw({}),
+    $extension:              markRaw({}),
     showWorkspaceSwitcher:   true,
     localCluster:            null,
   };
@@ -775,6 +776,7 @@ export const mutations = {
   },
 
   setPlugin(state, pluginDefinition) {
+    state.$extension = markRaw(pluginDefinition || {});
     state.$plugin = markRaw(pluginDefinition || {});
   },
 
@@ -1195,7 +1197,7 @@ export const actions = {
 
     store.dispatch('gcStopIntervals');
 
-    Object.values(this.$plugin.getPlugins()).forEach((p) => {
+    Object.values(this.$extension.getPlugins()).forEach((p) => {
       if (p.onLogOut) {
         p.onLogOut(store);
       }
@@ -1254,7 +1256,7 @@ export const actions = {
   dashboardClientInit({ dispatch, commit, rootState }, context) {
     commit('setRouter', context.app.router);
     commit('setRoute', context.route);
-    commit('setPlugin', context.app.$plugin);
+    commit('setPlugin', context.app.$extension);
 
     dispatch('management/rehydrateSubscribe');
     dispatch('cluster/rehydrateSubscribe');

package/store/notifications.ts

@@ -299,6 +299,8 @@ export const actions = {
 
     // Show a growl for the notification if necessary
     dispatch('growl/notification', notification, { root: true });
+
+    return notification.id;
   },
 
   async fromGrowl( { commit, getters }: any, notification: Notification) {

package/store/prefs.js

@@ -233,13 +233,13 @@ export const getters = {
       }
       const clusterPref = getters['get'](CLUSTER);
 
-      return { name: 'c-cluster-explorer', params: { product: 'explorer', cluster: clusterPref } };
+      return { name: 'c-cluster-explorer', params: { cluster: clusterPref } };
     }
     case (!!afterLoginRoutePref.match(/.+-dashboard$/)):
     {
       const clusterId = afterLoginRoutePref.split('-dashboard')[0];
 
-      return { name: 'c-cluster-explorer', params: { product: 'explorer', cluster: clusterId } };
+      return { name: 'c-cluster-explorer', params: { cluster: clusterId } };
     }
     default:
       return { name: afterLoginRoutePref };