@rancher/shell 2.0.0 → 2.0.2-rc.1

package/config/roles.ts

@@ -1,3 +1,17 @@
+export const enum SCOPED_RESOURCE_GROUPS {
+  GLOBAL = 'globalScopedApiGroups', // eslint-disable-line no-unused-vars
+  CLUSTER = 'clusterScopedApiGroups', // eslint-disable-line no-unused-vars
+  PROJECT_NAMESPACE = 'projectScopedApiGroups', // eslint-disable-line no-unused-vars
+}
+
+/**
+ * Resources users can select when creating grants when managing global, cluster and project/namespace roles
+ *
+ * **************NOTE*****************
+ * Global roles will show ALL entries
+ * Cluster roles will show cluster AND project/namespace entries
+ * Project/Namespace roles will show ONLY project/namespace entries
+ */
 export const SCOPED_RESOURCES = {
   // With this hardcoded list, it will be easier to curate a more useful
   // and human-understandable list of resources to choose from
@@ -13,7 +27,7 @@ export const SCOPED_RESOURCES = {
   // the global scoped list, and the project role creation form includes a
   // subset of the cluster scoped list.
 
-  globalScopedApiGroups: {
+  [SCOPED_RESOURCE_GROUPS.GLOBAL]: {
     // Global scoped resources are resources for
     // Rancher's global apps, mainly Cluster
     // Management and Continuous Delivery.
@@ -130,9 +144,9 @@ export const SCOPED_RESOURCES = {
       resources: [
         'Clusters'
       ]
-    }
+    },
   },
-  clusterScopedApiGroups: {
+  [SCOPED_RESOURCE_GROUPS.CLUSTER]: {
     // Cluster scoped resources are for non-namespaced
     // resources at the cluster level, for example,
     // storage resources.
@@ -201,15 +215,16 @@ export const SCOPED_RESOURCES = {
     },
     neuvectorApi: {
       resources: [
-        'nv-perm.admctrl',
-        'nv-perm.authentication',
-        'nv-perm.ci-scan',
-        'nv-perm.fed',
-        'nv-perm.vulnerability'
+        'AdmissionControl',
+        'Authentication',
+        'CIScan',
+        'Cluster',
+        'Federation',
+        'Vulnerability',
       ]
     }
   },
-  projectScopedApiGroups: {
+  [SCOPED_RESOURCE_GROUPS.PROJECT_NAMESPACE]: {
     // Project scoped resources include all other namespaced
     // resources.
     coreKubernetesApi: {
@@ -378,16 +393,16 @@ export const SCOPED_RESOURCES = {
     },
     neuvectorApi: {
       resources: [
-        'nv-perm.all-permissions',
-        'nv-perm.audit-events',
-        'nv-perm.authorization',
-        'nv-perm.compliance',
-        'nv-perm.events',
-        'nv-perm.reg-scan',
-        'nv-perm.rt-policy',
-        'nv-perm.rt-scan',
-        'nv-perm.security-events',
-        'nv-perm.config',
+        'AuditEvents',
+        'Authorization',
+        'Compliance',
+        'Events',
+        'Namespace',
+        'RegistryScan',
+        'RuntimePolicy',
+        'RuntimeScan',
+        'SecurityEvents',
+        'SystemConfig',
       ]
     }
   }

package/config/router/navigation-guards/attempt-first-login.js

@@ -5,7 +5,7 @@ import { tryInitialSetup } from '@shell/utils/auth';
 import { routeRequiresAuthentication } from '@shell/utils/router';
 
 export function install(router, context) {
-  router.beforeEach((to, from, next) => attemptFirstLogin(to, from, next, context));
+  router.beforeEach(async(to, from, next) => await attemptFirstLogin(to, from, next, context));
 }
 
 export async function attemptFirstLogin(to, from, next, { store }) {

package/config/router/navigation-guards/authentication.js

@@ -2,7 +2,7 @@ import { routeRequiresAuthentication } from '@shell/utils/router';
 import { isLoggedIn, notLoggedIn, noAuth, findMe } from '@shell/utils/auth';
 
 export function install(router, context) {
-  router.beforeEach((to, from, next) => authenticate(to, from, next, context));
+  router.beforeEach(async(to, from, next) => await authenticate(to, from, next, context));
 }
 
 export async function authenticate(to, from, next, { store }) {

package/config/router/navigation-guards/i18n.js

@@ -0,0 +1,13 @@
+export function install(router, context) {
+  router.beforeEach(async(to, from, next) => await loadI18n(to, from, next, context));
+}
+
+export async function loadI18n(to, from, next, { store }) {
+  try {
+    await store.dispatch('i18n/init');
+  } catch (e) {
+    console.error('Failed to initialize i18n', e); // eslint-disable-line no-console
+  }
+
+  next();
+}

package/config/router/navigation-guards/index.js

@@ -1,6 +1,8 @@
 import { install as installLoadInitialSettings } from '@shell/config/router/navigation-guards/load-initial-settings';
 import { install as installAttemptFirstLogin } from '@shell/config/router/navigation-guards/attempt-first-login';
 import { install as installAuthentication } from '@shell/config/router/navigation-guards/authentication';
+import { install as installRuntimeExtensionRoute } from '@shell/config/router/navigation-guards/runtime-extension-route';
+import { install as installI18N } from '@shell/config/router/navigation-guards/i18n';
 
 /**
  * Install our router navigation guards. i.e. router.beforeEach(), router.afterEach()
@@ -9,7 +11,7 @@ export function installNavigationGuards(router, context) {
   // NOTE: the order of the installation matters.
   // Be intentional when adding, removing or modifying the guards that are installed.
 
-  const navigationGuardInstallers = [installLoadInitialSettings, installAttemptFirstLogin, installAuthentication];
+  const navigationGuardInstallers = [installLoadInitialSettings, installAttemptFirstLogin, installAuthentication, installRuntimeExtensionRoute, installI18N];
 
   navigationGuardInstallers.forEach((installer) => installer(router, context));
 }

package/config/router/navigation-guards/load-initial-settings.js

@@ -1,7 +1,7 @@
 import { fetchInitialSettings } from '@shell/utils/settings';
 
 export function install(router, context) {
-  router.beforeEach((to, from, next) => loadInitialSettings(to, from, next, context));
+  router.beforeEach(async(to, from, next) => await loadInitialSettings(to, from, next, context));
 }
 
 export async function loadInitialSettings(to, from, next, { store }) {

package/config/router/navigation-guards/runtime-extension-route.js

@@ -0,0 +1,31 @@
+import dynamicPluginLoader from '@shell/pkg/dynamic-plugin-loader';
+import { routeRequiresAuthentication } from '@shell/utils/router';
+
+export function install(router, context) {
+  router.beforeEach((to, from, next) => runtimeExtensionRoute(to, from, next, context));
+}
+
+export async function runtimeExtensionRoute(to, from, next, { store }) {
+  if (!routeRequiresAuthentication(to) || to.name !== '404') {
+    return next();
+  }
+
+  try {
+    // Handle the loading of dynamic plugins (Harvester) because we only want to attempt to load those plugins and routes if we first couldn't find a page.
+    // We should probably get rid of this concept entirely and just load plugins at the start.
+    await store.dispatch('loadManagement');
+    const newLocation = await dynamicPluginLoader.check({ route: { path: window.location.pathname }, store });
+
+    // If we have a new location, double check that it's actually valid
+    const resolvedRoute = newLocation?.path ? store.app.router.resolve({ path: newLocation.path.replace(/^\/{0,1}dashboard/, '') }) : null;
+
+    if (resolvedRoute?.route.matched.length) {
+      // Note - don't use `redirect` or `store.app.route` (breaks feature by failing to run middleware in default layout)
+      return next(resolvedRoute.resolved.path);
+    }
+  } catch (e) {
+    console.error('Failed to load harvester', e); // eslint-disable-line no-console
+  }
+
+  next();
+}

package/config/router/routes.js

@@ -41,6 +41,7 @@ export default [
     path:      '',
     component: () => interopDefault(import('@shell/components/templates/home.vue')),
     meta:      { requiresAuthentication: true },
+    name:      'home_layout',
     children:  [
       {
         path:      '/home',
@@ -484,4 +485,12 @@ export default [
         component: () => interopDefault(import('@shell/pages/c/_cluster/_product/_resource/_namespace/_id.vue')),
         name:      'c-cluster-product-resource-namespace-id'
       }]
-  }];
+  },
+  {
+    path:      '*',
+    name:      '404',
+    component: () => interopDefault(import('@shell/pages/404.vue')),
+    meta:      { requiresAuthentication: true },
+  },
+
+];

package/config/uiplugins.js

@@ -68,6 +68,36 @@ export const UI_PLUGIN_METADATA = {
   DISPLAY_NAME:      'displayName',
 };
 
+export const EXTENSIONS_INCOMPATIBILITY_TYPES = {
+  UI:             'uiVersion',
+  EXTENSIONS_API: 'extensionsApiVersion',
+  KUBE:           'kubeVersion',
+  HOST:           'host'
+};
+
+export const EXTENSIONS_INCOMPATIBILITY_DATA = {
+  UI: {
+    type:           EXTENSIONS_INCOMPATIBILITY_TYPES.UI,
+    cardMessageKey: 'plugins.incompatibleRancherVersion',
+    tooltipKey:     'plugins.info.requiresRancherVersion',
+  },
+  EXTENSIONS_API: {
+    type:           EXTENSIONS_INCOMPATIBILITY_TYPES.EXTENSIONS_API,
+    cardMessageKey: 'plugins.incompatibleUiExtensionsApiVersion',
+    tooltipKey:     'plugins.info.requiresExtensionApiVersion',
+  },
+  KUBE: {
+    type:           EXTENSIONS_INCOMPATIBILITY_TYPES.KUBE,
+    cardMessageKey: 'plugins.incompatibleKubeVersion',
+    tooltipKey:     'plugins.info.requiresKubeVersion',
+  },
+  HOST: {
+    type:           EXTENSIONS_INCOMPATIBILITY_TYPES.HOST,
+    cardMessageKey: 'plugins.incompatibleHost',
+    tooltipKey:     'plugins.info.requiresHost',
+  }
+};
+
 export function isUIPlugin(chart) {
   return !!chart?.versions.find((v) => {
     return v.annotations && v.annotations[UI_PLUGIN_ANNOTATION_NAME] === UI_PLUGIN_ANNOTATION_VALUE;
@@ -91,130 +121,169 @@ export function uiPluginAnnotation(chart, name) {
   return undefined;
 }
 
+/**
+ * Parse the rancher version string
+ */
+function parseRancherVersion(v) {
+  let parsedRancherVersion = semver.coerce(v)?.version;
+  const splitArr = parsedRancherVersion.split('.');
+
+  // this is a scenario where we are on a "head" version of some sort... we can't infer the patch version from it
+  // so we apply a big patch version number to make sure we follow through with the minor
+  if (v.includes('-') && splitArr?.length === 3) {
+    parsedRancherVersion = `${ splitArr[0] }.${ splitArr[1] }.999`;
+  }
+
+  return parsedRancherVersion;
+}
+
 // i18n-uses plugins.error.generic, plugins.error.api, plugins.error.host
 
-// Should we load a plugin, based on the metadata returned by the backend?
-// Returns error key string or false
-export function shouldNotLoadPlugin(plugin, rancherVersion, loadedPlugins) {
-  if (!plugin.name || !plugin.version || !plugin.endpoint) {
+/**
+ * Whether an extension should be loaded based on the metadata returned by the backend in the UIPlugins resource instance
+ * @returns String || Boolean
+ */
+export function shouldNotLoadPlugin(UIPluginResource, rancherVersion, loadedPlugins) {
+  if (!UIPluginResource.name || !UIPluginResource.version || !UIPluginResource.endpoint) {
     return 'plugins.error.generic';
   }
 
-  // Plugin specified a required extension API version
+  // Extension chart specified a required extension API version
   // we are propagating the annotations in pkg/package.json for any extension
   // inside the "spec.plugin.metadata" property of UIPlugin resource
-  const requiredAPI = plugin.spec?.plugin?.metadata?.[UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION];
+  const requiredUiExtensionsVersion = UIPluginResource.spec?.plugin?.metadata?.[UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION];
+  // semver.coerce will get rid of any suffix on the version numbering (-rc, -head, etc)
+  const parsedUiExtensionsApiVersion = semver.coerce(UI_EXTENSIONS_API_VERSION)?.version || UI_EXTENSIONS_API_VERSION;
+  const parsedRancherVersion = rancherVersion ? parseRancherVersion(rancherVersion) : '';
 
-  if (requiredAPI && !semver.satisfies(UI_EXTENSIONS_API_VERSION, requiredAPI)) {
+  if (requiredUiExtensionsVersion && !semver.satisfies(parsedUiExtensionsApiVersion, requiredUiExtensionsVersion)) {
     return 'plugins.error.api';
   }
 
   // Host application
-  const requiredHost = plugin.metadata?.[UI_PLUGIN_METADATA.EXTENSIONS_HOST];
+  const requiredHost = UIPluginResource.metadata?.[UI_PLUGIN_METADATA.EXTENSIONS_HOST];
 
   if (requiredHost && requiredHost !== UI_PLUGIN_HOST_APP) {
     return 'plugins.error.host';
   }
 
   // Rancher version
-  if (rancherVersion) {
-    const requiredRancherVersion = plugin.metadata?.[UI_PLUGIN_METADATA.RANCHER_VERSION];
+  if (parsedRancherVersion) {
+    const requiredRancherVersion = UIPluginResource.metadata?.[UI_PLUGIN_METADATA.RANCHER_VERSION];
 
-    if (requiredRancherVersion && !semver.satisfies(rancherVersion, requiredRancherVersion)) {
+    if (requiredRancherVersion && !semver.satisfies(parsedRancherVersion, requiredRancherVersion)) {
       return 'plugins.error.version';
     }
   }
 
   // check if a builtin extension has been loaded before - improve developer experience
-  const checkLoaded = loadedPlugins.find((p) => p?.name === plugin?.name);
+  const checkLoaded = loadedPlugins.find((p) => p?.name === UIPluginResource?.name);
 
   if (checkLoaded && checkLoaded.builtin) {
     return 'plugins.error.developerPkg';
   }
 
-  if (plugin.metadata?.[UI_PLUGIN_LABELS.CATALOG]) {
+  if (UIPluginResource.metadata?.[UI_PLUGIN_LABELS.CATALOG]) {
     return true;
   }
 
   return false;
 }
 
-// Can a chart version be used for this Rancher (based on the annotations on the chart)?
-export function isSupportedChartVersion(versionsData) {
-  const { version, rancherVersion, kubeVersion } = versionsData;
+/**
+ * Wether an extension version is available to be installed, based on the annotations present in the Helm chart version
+ * backend may not automatically "limit" a particular version but dashboard will disable that version for install with this check
+ * @returns Boolean || Object
+ */
+export function isSupportedChartVersion(versionData, returnObj = false) {
+  const { version, rancherVersion, kubeVersion } = versionData;
 
-  // Plugin specified a required extension API version
-  const requiredAPI = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION];
+  // semver.coerce will get rid of any suffix on the version numbering (-rc, -head, etc)
+  const parsedRancherVersion = rancherVersion ? parseRancherVersion(rancherVersion) : '';
+  const requiredUiVersion = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.UI_VERSION];
+  const requiredKubeVersion = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.KUBE_VERSION];
+  const versionObj = { ...version };
 
-  if (requiredAPI && !semver.satisfies(UI_EXTENSIONS_API_VERSION, requiredAPI)) {
-    return false;
-  }
+  // reset compatibility property
+  versionObj.isVersionCompatible = true;
+  versionObj.versionIncompatibilityData = {};
 
-  // Host application
-  const requiredHost = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_HOST];
+  // check "catalog.cattle.io/kube-version" annotation
+  // we keep it as first check since there is a card notification to be displayed
+  // in case an extension version installed has an incompatibility with the kube version and is not loaded
+  if (kubeVersion && requiredKubeVersion && !semver.satisfies(kubeVersion, requiredKubeVersion)) {
+    if (!returnObj) {
+      return false;
+    }
 
-  if (requiredHost && requiredHost !== UI_PLUGIN_HOST_APP) {
-    return false;
+    versionObj.isVersionCompatible = false;
+    versionObj.versionIncompatibilityData = Object.assign({}, EXTENSIONS_INCOMPATIBILITY_DATA.KUBE);
+    versionObj.versionIncompatibilityData.required = requiredKubeVersion;
+
+    return versionObj;
   }
 
-  // Rancher version
-  if (rancherVersion) {
+  // we aren't on a "published" version of Rancher and therefore in a "-head" or similar
+  // Backend will NOT block an extension version from being available IF we are on HEAD versions!!
+  // we need to enforce that check if we are on a HEAD world
+  if (rancherVersion && rancherVersion.includes('-')) {
     const requiredRancherVersion = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.RANCHER_VERSION];
 
-    if (requiredRancherVersion && !semver.satisfies(rancherVersion, requiredRancherVersion)) {
-      return false;
+    if (parsedRancherVersion && !semver.satisfies(parsedRancherVersion, requiredRancherVersion)) {
+      if (!returnObj) {
+        return false;
+      }
+
+      versionObj.isVersionCompatible = false;
+      versionObj.versionIncompatibilityData = Object.assign({}, EXTENSIONS_INCOMPATIBILITY_DATA.UI);
+      versionObj.versionIncompatibilityData.required = requiredRancherVersion;
+
+      return versionObj;
     }
   }
 
-  // Kube version
-  if (kubeVersion) {
-    const requiredKubeVersion = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.KUBE_VERSION];
+  // check host application
+  const requiredHost = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_HOST];
 
-    if (requiredKubeVersion && !semver.satisfies(kubeVersion, requiredKubeVersion)) {
+  if (requiredHost && requiredHost !== UI_PLUGIN_HOST_APP) {
+    if (!returnObj) {
       return false;
     }
-  }
 
-  return true;
-}
-
-export function isChartVersionAvailableForInstall(versionsData, returnObj = false) {
-  const { version, rancherVersion, kubeVersion } = versionsData;
+    versionObj.isVersionCompatible = false;
+    versionObj.versionIncompatibilityData = Object.assign({}, EXTENSIONS_INCOMPATIBILITY_DATA.HOST);
+    versionObj.versionIncompatibilityData.required = requiredHost;
 
-  const parsedRancherVersion = rancherVersion.split('-')?.[0];
-  const regexHashString = new RegExp('^[A-Za-z0-9]{9}$');
-  const isRancherVersionHashString = regexHashString.test(rancherVersion);
-  const requiredUiVersion = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.UI_VERSION];
-  const requiredKubeVersion = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.KUBE_VERSION];
-  const versionObj = { ...version };
+    return versionObj;
+  }
 
-  versionObj.isCompatibleWithUi = true;
-  versionObj.isCompatibleWithKubeVersion = true;
+  // check "catalog.cattle.io/ui-extensions-version" annotation
+  const requiredUiExtensionsApiVersion = version.annotations?.[UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION];
+  const parsedUiExtensionsApiVersion = semver.coerce(UI_EXTENSIONS_API_VERSION)?.version || UI_EXTENSIONS_API_VERSION;
 
-  // if it's a head version of Rancher, then we skip the validation and enable them all
-  if (!isRancherVersionHashString && requiredUiVersion && !semver.satisfies(parsedRancherVersion, requiredUiVersion)) {
+  if (requiredUiExtensionsApiVersion && parsedUiExtensionsApiVersion && !semver.satisfies(parsedUiExtensionsApiVersion, requiredUiExtensionsApiVersion)) {
     if (!returnObj) {
       return false;
     }
-    versionObj.isCompatibleWithUi = false;
-    versionObj.requiredUiVersion = requiredUiVersion;
 
-    if (returnObj) {
-      return versionObj;
-    }
+    versionObj.isVersionCompatible = false;
+    versionObj.versionIncompatibilityData = Object.assign({}, EXTENSIONS_INCOMPATIBILITY_DATA.EXTENSIONS_API);
+    versionObj.versionIncompatibilityData.required = requiredUiExtensionsApiVersion;
+
+    return versionObj;
   }
 
-  // check kube version
-  if (kubeVersion && requiredKubeVersion && !semver.satisfies(kubeVersion, requiredKubeVersion)) {
+  // check "catalog.cattle.io/ui-version" annotation
+  if (requiredUiVersion && parsedRancherVersion && !semver.satisfies(parsedRancherVersion, requiredUiVersion)) {
     if (!returnObj) {
       return false;
     }
-    versionObj.isCompatibleWithKubeVersion = false;
-    versionObj.requiredKubeVersion = requiredKubeVersion;
 
-    if (returnObj) {
-      return versionObj;
-    }
+    versionObj.isVersionCompatible = false;
+    versionObj.versionIncompatibilityData = Object.assign({}, EXTENSIONS_INCOMPATIBILITY_DATA.UI);
+    versionObj.versionIncompatibilityData.required = requiredUiVersion;
+
+    return versionObj;
   }
 
   if (returnObj) {

package/core/plugin.ts

@@ -132,6 +132,11 @@ export class Plugin implements IPlugin {
         console.warn(`Layouts have been deprecated. We still have parent routes which use the same name and styling as the previous layouts. You should specify a parent, we're currently setting the parent to 'default'`); // eslint-disable-line no-console
         parentOverride = 'default';
       }
+
+      // Fix for Home page components with wrong layout - need to ensure the parentOverride is set
+      if (typelessRoute.component && typelessRoute.name === 'home' && typelessRoute.path === '/home') {
+        parentOverride = 'home_layout';
+      }
     }
 
     route.meta = {

package/core/plugins.js

@@ -90,6 +90,10 @@ export default function(context, inject, vueApp) {
               delete window[oldPlugin.id];
 
               delete plugins[oldPlugin.id];
+
+              const oldElement = document.getElementById(oldPlugin.id);
+
+              oldElement.parentElement.removeChild(oldElement);
             });
           }
 
@@ -124,7 +128,9 @@ export default function(context, inject, vueApp) {
             };
 
             element.onerror = (e) => {
-            // Massage the error into something useful
+              element.parentElement.removeChild(element);
+
+              // Massage the error into something useful
               const errorMessage = `Failed to load script from '${ e.target.src }'`;
 
               console.error(errorMessage, e); // eslint-disable-line no-console

package/detail/__tests__/provisioning.cattle.io.cluster.test.ts

@@ -73,5 +73,47 @@ describe('view: provisioning.cattle.io.cluster', () => {
 
       expect(wrapper.vm.showRegistration).toStrictEqual(false);
     });
+
+    it('should SHOW if custom/imported cluster and the cluster is active', async() => {
+      const value = {
+        isCustom:   true,
+        isImported: true,
+        mgmt:       {
+          hasLink: () => jest.fn(),
+          linkFor: () => '',
+          isReady: true
+        }
+      };
+
+      const wrapper = shallowMount(ProvisioningCattleIoCluster, {
+        mocks,
+        propsData: { value },
+      });
+
+      await wrapper.setData({ clusterToken: {} });
+
+      expect(wrapper.vm.showRegistration).toStrictEqual(true);
+    });
+
+    it('should NOT show if imported cluster and the cluster is active', async() => {
+      const value = {
+        isCustom:   false,
+        isImported: true,
+        mgmt:       {
+          hasLink: () => jest.fn(),
+          linkFor: () => '',
+          isReady: true
+        }
+      };
+
+      const wrapper = shallowMount(ProvisioningCattleIoCluster, {
+        mocks,
+        propsData: { value },
+      });
+
+      await wrapper.setData({ clusterToken: {} });
+
+      expect(wrapper.vm.showRegistration).toStrictEqual(false);
+    });
   });
 });

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

@@ -512,14 +512,14 @@ export default {
         return false;
       }
 
-      if ( this.value.isImported ) {
-        return !this.value.mgmt?.isReady && this.extDetailTabs.registration;
-      }
-
       if ( this.value.isCustom ) {
         return this.extDetailTabs.registration;
       }
 
+      if ( this.value.isImported ) {
+        return !this.value.mgmt?.isReady && this.extDetailTabs.registration;
+      }
+
       // Hosted kubernetes providers with private endpoints need the registration tab
       // https://github.com/rancher/dashboard/issues/6036
       // https://github.com/rancher/dashboard/issues/4545

package/dialog/DeactivateDriverDialog.vue

@@ -3,6 +3,8 @@ import AsyncButton from '@shell/components/AsyncButton';
 import { Card } from '@components/Card';
 import { Banner } from '@components/Banner';
 import { exceptionToErrorsArray } from '@shell/utils/error';
+import { resourceNames } from '@shell/utils/string';
+import { mapGetters } from 'vuex';
 
 export default {
   components: {
@@ -12,20 +14,35 @@ export default {
   },
 
   props: {
-    url: {
-      type:    String,
-      default: null,
+    drivers: {
+      type:     Array,
+      required: true
     },
-    name: {
-      type:    String,
-      default: null,
+    driverType: {
+      type:     String,
+      required: true
     }
   },
 
   data() {
     return { errors: [] };
   },
+  computed: {
+    formattedText() {
+      const namesSliced = this.drivers.map((obj) => obj.nameDisplay).slice(0, 5);
+      const remaining = this.drivers.length - namesSliced.length;
+
+      const plusMore = this.t('drivers.deactivate.andOthers', { count: remaining });
+      const names = resourceNames(namesSliced, plusMore, this.t);
+      const count = remaining || namesSliced.length;
+      const warningDrivers = this.t('drivers.deactivate.warningDrivers', { names, count });
+
+      return this.t('drivers.deactivate.warning', { warningDrivers, count: namesSliced.length });
+    },
+    ...mapGetters({ t: 'i18n/t' }),
+  },
   methods: {
+    resourceNames,
     close(buttonDone) {
       if (buttonDone && typeof buttonDone === 'function') {
         buttonDone(true);
@@ -34,10 +51,12 @@ export default {
     },
     async apply(buttonDone) {
       try {
-        await this.$store.dispatch('rancher/request', {
-          url:    this.url,
-          method: 'post'
-        });
+        await Promise.all(this.drivers.map(
+          (driver) => this.$store.dispatch('rancher/request', {
+            url:    `v3/${ this.driverType }/${ escape(driver.id) }?action=deactivate`,
+            method: 'POST'
+          })
+        ));
 
         this.close(buttonDone);
       } catch (err) {
@@ -64,7 +83,7 @@ export default {
     <template #body>
       <div class="pl-10 pr-10">
         <div class="text info mb-10 mt-20">
-          <span v-clean-html="t('drivers.deactivate.warning', {name})" />
+          <span v-clean-html="formattedText" />
         </div>
         <Banner
           v-for="(err, i) in errors"