@openshift-assisted/ui-lib 5.0.0-cim → 5.0.1-cim

package/lib/ocm/components/clusterConfiguration/manifestsConfiguration/components/CustomManifestsForm.tsx

@@ -23,6 +23,7 @@ import { CustomManifestValues, ManifestFormData } from '../data/dataTypes';
 import useClusterCustomManifests from '../../../../hooks/useClusterCustomManifests';
 import { ClustersService } from '../../../../services';
 import { CustomManifestsArray } from './CustomManifestsArray';
+import { userProvidedManifests } from './utils';
 import { selectCurrentClusterPermissionsState } from '../../../../store/slices/current-cluster/selectors';
 import { useClusterWizardContext } from '../../../clusterWizard/ClusterWizardContext';
 import { ClustersAPI } from '../../../../services/apis';
@@ -70,7 +71,8 @@ export const CustomManifestsForm = ({
     if (customManifests && !customManifestsLocalRef.current.length) {
       const initValues = getInitialValues(customManifests);
       setInitialValues(initValues);
-      customManifestsLocalRef.current = !!customManifests.length ? initValues.manifests : [];
+      customManifestsLocalRef.current =
+        userProvidedManifests(customManifests).length > 0 ? initValues.manifests : [];
     }
   }, [customManifests, getInitialValues]);
 

package/lib/ocm/components/clusterConfiguration/manifestsConfiguration/components/utils.tsx

@@ -1,5 +1,10 @@
 import { CustomManifestValues, ListManifestsExtended, ManifestFormData } from '../data/dataTypes';
 
+/** Manifests created by the installer (e.g. OVE defaults); not editable in the wizard. */
+export const userProvidedManifests = <T extends { manifestSource?: string }>(
+  manifests: T[] | undefined,
+): T[] => (manifests ?? []).filter((m) => m.manifestSource !== 'system');
+
 export const getManifestName = (manifestIdx: number) => `Custom manifest ${manifestIdx + 1}`;
 
 export const getFormData = (manifests: ListManifestsExtended): ManifestFormData => {
@@ -18,11 +23,11 @@ export const getEmptyManifest = (): CustomManifestValues => {
 };
 
 export const getManifestValues = (manifests: ListManifestsExtended): ManifestFormData => {
-  if (!!manifests.length) {
-    return getFormData(manifests);
-  } else {
-    return getEmptyManifestsValues();
+  const userManifests = userProvidedManifests(manifests);
+  if (userManifests.length > 0) {
+    return getFormData(userManifests);
   }
+  return getEmptyManifestsValues();
 };
 
 export const getEmptyManifestsValues = (): ManifestFormData => {
@@ -32,8 +37,9 @@ export const getEmptyManifestsValues = (): ManifestFormData => {
 export const getClusterCustomManifests = (
   customManifests: ListManifestsExtended,
 ): CustomManifestValues[] => {
-  if (customManifests && customManifests.length > 0) {
-    return customManifests.map((manifest) => ({
+  const userManifests = userProvidedManifests(customManifests);
+  if (userManifests.length > 0) {
+    return userManifests.map((manifest) => ({
       folder: manifest.folder || 'manifests',
       filename: manifest.fileName || '',
       manifestYaml: manifest.yamlContent || '',

package/lib/ocm/components/clusterConfiguration/networkConfiguration/NetworkConfiguration.tsx

@@ -6,13 +6,16 @@ import {
   canBeDualStack,
   CpuArchitecture,
   DUAL_STACK,
+  getIPv6FromDualstack,
   HostSubnets,
   isAdvNetworkConf,
   isSNO,
   NetworkConfigurationValues,
+  NO_SUBNET_SET,
   selectApiVip,
   selectIngressVip,
 } from '../../../../common';
+import { Address6 } from 'ip-address';
 import {
   ManagedNetworkingControlGroup,
   UserManagedNetworkingTextContent,
@@ -36,6 +39,7 @@ import {
 } from '@openshift-assisted/types/assisted-installer-service';
 import useSupportLevelsAPI from '../../../hooks/useSupportLevelsAPI';
 import { isOciPlatformType } from '../../utils';
+import { useFeature } from '../../../hooks/use-feature';
 
 export type NetworkConfigurationProps = VirtualIPControlGroupProps & {
   hostSubnets: HostSubnets;
@@ -122,6 +126,33 @@ const getManagedNetworkingState = (
   };
 };
 
+type DefaultNetworkSettings = NetworkConfigurationProps['defaultNetworkSettings'];
+
+const getNetworkDefaultsByFamily = (
+  settings: DefaultNetworkSettings,
+  isDualStack: boolean,
+  isIPv6: boolean,
+) => {
+  if (isDualStack) {
+    return {
+      clusterNetworkDefaults: settings.clusterNetworksDualstack,
+      serviceNetworkDefaults: settings.serviceNetworksDualstack,
+    };
+  }
+  if (isIPv6) {
+    const ipv6Cluster = getIPv6FromDualstack(settings.clusterNetworksDualstack);
+    const ipv6Service = getIPv6FromDualstack(settings.serviceNetworksDualstack);
+    return {
+      clusterNetworkDefaults: ipv6Cluster ? [ipv6Cluster] : settings.clusterNetworksIpv4,
+      serviceNetworkDefaults: ipv6Service ? [ipv6Service] : settings.serviceNetworksIpv4,
+    };
+  }
+  return {
+    clusterNetworkDefaults: settings.clusterNetworksIpv4,
+    serviceNetworkDefaults: settings.serviceNetworksIpv4,
+  };
+};
+
 const NetworkConfiguration = ({
   cluster,
   hostSubnets,
@@ -136,8 +167,10 @@ const NetworkConfiguration = ({
     cluster.platform?.type,
   );
   const { isViewerMode } = useSelector(selectCurrentClusterPermissionsState);
-  const { setFieldValue, values, validateField } = useFormikContext<NetworkConfigurationValues>();
+  const { setFieldValue, values, validateField, validateForm } =
+    useFormikContext<NetworkConfigurationValues>();
 
+  const isSingleClusterFeature = useFeature('ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE');
   const isSNOCluster = isSNO(cluster);
   const isUserManagedNetworking = values.managedNetworkingType === 'userManaged';
   const isDualStack = values.stackType === DUAL_STACK;
@@ -177,30 +210,18 @@ const NetworkConfiguration = ({
       setAdvanced(checked);
 
       if (!checked) {
-        setFieldValue(
-          'clusterNetworks',
-          isDualStack
-            ? defaultNetworkSettings.clusterNetworksDualstack
-            : defaultNetworkSettings.clusterNetworksIpv4,
-          true,
-        );
-        setFieldValue(
-          'serviceNetworks',
-          isDualStack
-            ? defaultNetworkSettings.serviceNetworksDualstack
-            : defaultNetworkSettings.serviceNetworksIpv4,
-          true,
+        const primaryCidr = values.machineNetworks?.[0]?.cidr;
+        const isIPv6Stack = !!primaryCidr && Address6.isValid(primaryCidr);
+        const { clusterNetworkDefaults, serviceNetworkDefaults } = getNetworkDefaultsByFamily(
+          defaultNetworkSettings,
+          isDualStack,
+          isIPv6Stack,
         );
+        setFieldValue('clusterNetworks', clusterNetworkDefaults, true);
+        setFieldValue('serviceNetworks', serviceNetworkDefaults, true);
       }
     },
-    [
-      setFieldValue,
-      isDualStack,
-      defaultNetworkSettings.clusterNetworksDualstack,
-      defaultNetworkSettings.clusterNetworksIpv4,
-      defaultNetworkSettings.serviceNetworksDualstack,
-      defaultNetworkSettings.serviceNetworksIpv4,
-    ],
+    [setFieldValue, isDualStack, values.machineNetworks, defaultNetworkSettings],
   );
 
   React.useEffect(() => {
@@ -209,6 +230,47 @@ const NetworkConfiguration = ({
     }
   }, [isDualStack, isViewerMode, toggleAdvConfiguration]);
 
+  React.useEffect(() => {
+    if (!isSingleClusterFeature || isViewerMode || isDualStack || isAdvanced) {
+      return;
+    }
+    const primaryCidr = values.machineNetworks?.[0]?.cidr;
+    if (!primaryCidr || primaryCidr === NO_SUBNET_SET) {
+      return;
+    }
+    const isIPv6 = Address6.isValid(primaryCidr);
+    const currentClusterCidr = values.clusterNetworks?.[0]?.cidr;
+    const clusterIsIPv6 = currentClusterCidr ? Address6.isValid(currentClusterCidr) : null;
+
+    if (clusterIsIPv6 === isIPv6) {
+      return;
+    }
+
+    const { clusterNetworkDefaults, serviceNetworkDefaults } = getNetworkDefaultsByFamily(
+      defaultNetworkSettings,
+      false,
+      isIPv6,
+    );
+    if (clusterNetworkDefaults) {
+      setFieldValue('clusterNetworks', clusterNetworkDefaults);
+    }
+    if (serviceNetworkDefaults) {
+      setFieldValue('serviceNetworks', serviceNetworkDefaults);
+    }
+    void validateForm();
+  }, [
+    isSingleClusterFeature,
+    isViewerMode,
+    isDualStack,
+    isAdvanced,
+    values.machineNetworks,
+    values.clusterNetworks,
+    defaultNetworkSettings,
+    setFieldValue,
+    validateForm,
+    cluster.id,
+  ]);
+
   const managedNetworkingState = React.useMemo(
     () =>
       getManagedNetworkingState(
@@ -252,6 +314,7 @@ const NetworkConfiguration = ({
             hostSubnets={hostSubnets}
             defaultNetworkValues={defaultNetworkSettings}
             isViewerMode={isViewerMode}
+            allowSingleStackIPv6={isSingleClusterFeature}
           />
         </StackItem>
       )}
@@ -277,6 +340,7 @@ const NetworkConfiguration = ({
             }
             openshiftVersion={cluster.openshiftVersion}
             isViewerMode={isViewerMode}
+            allowSingleStackIPv6={isSingleClusterFeature}
           />
         </StackItem>
       )}

package/lib/ocm/components/clusterConfiguration/networkConfiguration/NetworkConfigurationForm.tsx

@@ -9,7 +9,7 @@ import {
   getFormikErrorFields,
   getHostSubnets,
   HostSubnets,
-  SINGLE_STACK,
+  DUAL_STACK,
   isSNO,
   LoadingState,
   NetworkConfigurationValues,
@@ -262,7 +262,7 @@ const NetworkConfigurationPage = ({ cluster }: { cluster: Cluster }) => {
         if (values.vipDhcpAllocation) {
           delete params.apiVips;
           delete params.ingressVips;
-        } else if (values.stackType === SINGLE_STACK) {
+        } else if (values.stackType !== DUAL_STACK) {
           // The API will rebuild the default machineNetwork
           params.machineNetworks = [];
         }

package/lib/ocm/components/clusterConfiguration/networkConfiguration/networkConfigurationValidation.ts

@@ -1,8 +1,11 @@
 import * as Yup from 'yup';
 import { TFunction } from 'i18next';
+import { Address6 } from 'ip-address';
 import {
   clusterNetworksValidationSchema,
   dualStackValidationSchema,
+  getIPv6FromDualstack,
+  isPrimaryIPv6,
   HostSubnets,
   isDualStack,
   isSNO,
@@ -10,6 +13,7 @@ import {
   NetworkConfigurationValues,
   serviceNetworkValidationSchema,
   IPv4ValidationSchema,
+  IPv6ValidationSchema,
   sshPublicKeyValidationSchema,
   SINGLE_STACK,
   DUAL_STACK,
@@ -36,6 +40,38 @@ export const getNetworkInitialValues = (
 ): NetworkConfigurationValues => {
   const isSNOCluster = isSNO(cluster);
   const isDualStackType = isDualStack(cluster);
+  const primaryMachineNetworkCidr = cluster.machineNetworks?.[0]?.cidr;
+  const isIPv6OnlyStack =
+    !isDualStackType && !!primaryMachineNetworkCidr && Address6.isValid(primaryMachineNetworkCidr);
+
+  const getStackType = (): NetworkConfigurationValues['stackType'] => {
+    if (isDualStackType) return DUAL_STACK;
+    return SINGLE_STACK;
+  };
+
+  const getDefaultClusterNetworks = () => {
+    if (isDualStackType) return defaultNetworkValues.clusterNetworksDualstack;
+    if (isIPv6OnlyStack) {
+      const ipv6Entry = getIPv6FromDualstack(defaultNetworkValues.clusterNetworksDualstack);
+      return ipv6Entry ? [{ ...ipv6Entry, clusterId: cluster?.id }] : undefined;
+    }
+    return defaultNetworkValues.clusterNetworksIpv4?.map((network) => ({
+      ...network,
+      clusterId: cluster?.id,
+    }));
+  };
+
+  const getDefaultServiceNetworks = () => {
+    if (isDualStackType) return defaultNetworkValues.serviceNetworksDualstack;
+    if (isIPv6OnlyStack) {
+      const ipv6Entry = getIPv6FromDualstack(defaultNetworkValues.serviceNetworksDualstack);
+      return ipv6Entry ? [{ ...ipv6Entry, clusterId: cluster?.id }] : undefined;
+    }
+    return defaultNetworkValues.serviceNetworksIpv4?.map((network) => ({
+      ...network,
+      clusterId: cluster?.id,
+    }));
+  };
 
   return {
     apiVips: cluster.apiVips,
@@ -50,23 +86,9 @@ export const getNetworkInitialValues = (
         : 'clusterManaged',
     networkType: cluster.networkType || NETWORK_TYPE_OVN,
     machineNetworks: cluster.machineNetworks || [],
-    stackType: isDualStackType ? DUAL_STACK : SINGLE_STACK,
-    clusterNetworks:
-      cluster.clusterNetworks ||
-      (isDualStackType
-        ? defaultNetworkValues.clusterNetworksDualstack
-        : defaultNetworkValues.clusterNetworksIpv4?.map((network) => ({
-            ...network,
-            clusterId: cluster?.id,
-          }))),
-    serviceNetworks:
-      cluster.serviceNetworks ||
-      (isDualStackType
-        ? defaultNetworkValues.serviceNetworksDualstack
-        : defaultNetworkValues.serviceNetworksIpv4?.map((network) => ({
-            ...network,
-            clusterId: cluster?.id,
-          }))),
+    stackType: getStackType(),
+    clusterNetworks: cluster.clusterNetworks || getDefaultClusterNetworks(),
+    serviceNetworks: cluster.serviceNetworks || getDefaultServiceNetworks(),
   };
 };
 
@@ -87,7 +109,12 @@ export const getNetworkConfigurationValidationSchema = (
           : machineNetworksValidationSchema.when('stackType', {
               is: (stackType: NetworkConfigurationValues['stackType']) =>
                 stackType === SINGLE_STACK,
-              then: () => machineNetworksValidationSchema.concat(IPv4ValidationSchema),
+              then: () => {
+                if (isPrimaryIPv6(values.machineNetworks)) {
+                  return machineNetworksValidationSchema.concat(IPv6ValidationSchema);
+                }
+                return machineNetworksValidationSchema.concat(IPv4ValidationSchema);
+              },
               otherwise: () =>
                 values.machineNetworks && values.machineNetworks?.length >= 2
                   ? machineNetworksValidationSchema.concat(
@@ -97,13 +124,23 @@ export const getNetworkConfigurationValidationSchema = (
             }),
       clusterNetworks: clusterNetworksValidationSchema(t).when('stackType', {
         is: (stackType: NetworkConfigurationValues['stackType']) => stackType === SINGLE_STACK,
-        then: (schema) => schema.concat(IPv4ValidationSchema),
+        then: (schema) => {
+          if (isPrimaryIPv6(values.machineNetworks)) {
+            return schema.concat(IPv6ValidationSchema);
+          }
+          return schema.concat(IPv4ValidationSchema);
+        },
         otherwise: (schema) =>
           schema.concat(dualStackValidationSchema('cluster network', t, openshiftVersion)),
       }),
       serviceNetworks: serviceNetworkValidationSchema(t).when('stackType', {
         is: (stackType: NetworkConfigurationValues['stackType']) => stackType === SINGLE_STACK,
-        then: (schema) => schema.concat(IPv4ValidationSchema),
+        then: (schema) => {
+          if (isPrimaryIPv6(values.machineNetworks)) {
+            return schema.concat(IPv6ValidationSchema);
+          }
+          return schema.concat(IPv4ValidationSchema);
+        },
         otherwise: (schema) =>
           schema.concat(dualStackValidationSchema('service network', t, openshiftVersion)),
       }),

package/lib/ocm/components/clusterConfiguration/operators/OperatorCheckbox.tsx

@@ -24,7 +24,6 @@ import {
 import NewFeatureSupportLevelBadge from '../../../../common/components/newFeatureSupportLevels/NewFeatureSupportLevelBadge';
 import { getFieldId, OperatorsValues, PopoverIcon } from '../../../../common';
 import { useNewFeatureSupportLevel } from '../../../../common/components/newFeatureSupportLevels';
-import { getNewOperators } from './utils';
 import {
   highlightMatch,
   OperatorSpec,
@@ -110,8 +109,10 @@ const OperatorRequirements = ({
 
 const OperatorCheckbox = ({
   bundles,
+  checkedOperatorIds,
   cluster,
   operatorId,
+  isChecked,
   title,
   featureId,
   notStandalone,
@@ -122,8 +123,10 @@ const OperatorCheckbox = ({
   searchTerm,
 }: {
   bundles: Bundle[];
+  checkedOperatorIds: Set<string>;
   cluster: Cluster;
   operatorId: string;
+  isChecked: boolean;
   openshiftVersion?: string;
   preflightRequirements: PreflightHardwareRequirements | undefined;
   searchTerm?: string;
@@ -135,32 +138,54 @@ const OperatorCheckbox = ({
   const { values, setFieldValue } = useFormikContext<OperatorsValues>();
   const fieldId = getFieldId(operatorId, 'input');
   const supportLevel = getFeatureSupportLevel(featureId);
+  const getDisabledReason = (): string | undefined => {
+    const featureDisabledReason = getFeatureDisabledReason(featureId);
+    if (featureDisabledReason) {
+      return featureDisabledReason;
+    }
 
-  const isInBundle = values.selectedBundles.some(
-    (sb) => !!bundles.find((b) => b.id === sb)?.operators?.includes(operatorId),
-  );
+    const isRequiredByBundle = values.selectedBundles.some(
+      (selectedBundle) =>
+        !!bundles
+          .find((bundle) => bundle.id === selectedBundle.id)
+          ?.operators?.includes(operatorId),
+    );
+    if (isRequiredByBundle) {
+      return 'This operator is part of a selected bundle and cannot be deselected.';
+    }
 
-  const isChecked = values.selectedOperators.includes(operatorId) || isInBundle;
+    const isOptionallySelectedForBundle = values.selectedBundles.some((selectedBundle) =>
+      selectedBundle.optionalOperators?.includes(operatorId),
+    );
+    if (isOptionallySelectedForBundle) {
+      return 'This optional operator is selected through a bundle. Use the bundle card to change it.';
+    }
 
-  const parentOperator = preflightRequirements?.operators?.find((op) =>
-    op.dependencies?.includes(operatorId),
-  );
+    const parentOperator = preflightRequirements?.operators?.find(
+      ({ operatorName, dependencies }) =>
+        !!operatorName &&
+        dependencies?.includes(operatorId) &&
+        checkedOperatorIds.has(operatorName),
+    );
+    if (parentOperator?.operatorName) {
+      const parentName = opSpecs[parentOperator.operatorName]?.title || parentOperator.operatorName;
+      return `This operator is required by ${parentName}`;
+    }
 
-  let parentOperatorName = '';
-  if (
-    parentOperator?.operatorName &&
-    values.selectedOperators.includes(parentOperator.operatorName)
-  ) {
-    parentOperatorName = opSpecs[parentOperator.operatorName]?.title || parentOperator.operatorName;
-  }
+    if (notStandalone && !checkedOperatorIds.has(operatorId)) {
+      return 'This operator cannot be installed as a standalone';
+    }
+
+    return undefined;
+  };
 
-  const disabledReason = isInBundle
-    ? 'This operator is part of a bundle and cannot be deselected.'
-    : notStandalone
-    ? 'This operator cannot be installed as a standalone'
-    : parentOperatorName
-    ? `This operator is a dependency of ${parentOperatorName}`
-    : getFeatureDisabledReason(featureId);
+  const disabledReason = getDisabledReason();
+  const handleClick = (_: React.FormEvent, checked: boolean) => {
+    const next = checked
+      ? [...values.selectedOperators, operatorId]
+      : values.selectedOperators.filter((op) => op !== operatorId);
+    setFieldValue('selectedOperators', next);
+  };
 
   return (
     <FormGroup fieldId={fieldId} id={`form-control__${fieldId}`}>
@@ -182,18 +207,7 @@ const OperatorCheckbox = ({
         }
         aria-describedby={`${fieldId}-helper`}
         isChecked={isChecked}
-        onChange={(_, checked) => {
-          setFieldValue(
-            'selectedOperators',
-            getNewOperators(
-              values.selectedOperators,
-              operatorId,
-              preflightRequirements,
-              checked,
-              opSpecs,
-            ),
-          );
-        }}
+        onChange={handleClick}
         isDisabled={isViewerMode || !!disabledReason}
         description={
           !!Description && (

package/lib/ocm/components/clusterConfiguration/operators/bundleSpecs.tsx

@@ -31,10 +31,9 @@ export const bundleSpecs: { [key: string]: BundleSpec } = {
     incompatibleBundles: [],
     Description: () => (
       <List>
-        <ListItem>GPUs are recommended for optimal AI/ML workload performance.</ListItem>
         <ListItem>
-          NVIDIA GPU, AMD GPU and Kernel Module Management may or may not be installed based on the
-          GPU discovered on your hosts.
+          GPUs are recommended for optimal AI/ML workload performance. Please select the GPU
+          operators you want to install.
         </ListItem>
       </List>
     ),

package/lib/ocm/components/clusterConfiguration/operators/utils.tsx

@@ -1,10 +1,9 @@
 import {
+  BundleCreateParams,
   Bundle,
   PreflightHardwareRequirements,
 } from '@openshift-assisted/types/assisted-installer-service';
-import { OperatorSpec } from '../../../../common/components/operators/operatorSpecs';
-
-const getOperatorDependencies = (
+export const getOperatorDependencies = (
   operatorId: string,
   preflightRequirements: PreflightHardwareRequirements | undefined,
   dependencies: Set<string> = new Set(),
@@ -25,36 +24,6 @@ const getOperatorDependencies = (
   return [...dependencies];
 };
 
-export const getNewOperators = (
-  currentOperators: string[],
-  operatorId: string,
-  preflightRequirements: PreflightHardwareRequirements | undefined,
-  add: boolean,
-  opSpecs: { [key: string]: OperatorSpec },
-): string[] => {
-  const dependencies = getOperatorDependencies(operatorId, preflightRequirements);
-
-  if (add) {
-    const uniqueOps = new Set([...currentOperators, ...dependencies, operatorId]);
-    return Array.from(uniqueOps);
-  }
-
-  const newOperators = currentOperators.filter((op) => op !== operatorId);
-  const notStandaloneDeps = dependencies
-    .filter((dep) => opSpecs[dep]?.notStandalone)
-    .filter((dep) => {
-      const hasDependency = newOperators.some((op) =>
-        getOperatorDependencies(op, preflightRequirements).includes(dep),
-      );
-      if (!hasDependency) {
-        newOperators.splice(newOperators.indexOf(dep), 1);
-      }
-      return !hasDependency;
-    });
-
-  return currentOperators.filter((op) => op !== operatorId && !notStandaloneDeps.includes(op));
-};
-
 const getBundleOperators = (
   bundle: Bundle,
   preflightRequirements: PreflightHardwareRequirements | undefined,
@@ -68,7 +37,7 @@ const getBundleOperators = (
 
 export const getNewBundleOperators = (
   currentOperators: string[],
-  currentBundles: string[],
+  currentBundles: BundleCreateParams[],
   allBundles: Bundle[],
   newBundle: Bundle,
   preflightRequirements: PreflightHardwareRequirements | undefined,
@@ -81,10 +50,10 @@ export const getNewBundleOperators = (
     return Array.from(new Set(combined));
   }
 
-  const newBundles = currentBundles.filter((b) => b !== newBundle.id);
+  const newBundles = currentBundles.filter((bundle) => bundle.id !== newBundle.id);
   const operatorsToKeep = [
-    ...newBundles.reduce((acc, bundleId) => {
-      const bundle = allBundles.find(({ id }) => id === bundleId);
+    ...newBundles.reduce((acc, selectedBundle) => {
+      const bundle = allBundles.find(({ id }) => id === selectedBundle.id);
       if (bundle) {
         const bundleOperators = getBundleOperators(bundle, preflightRequirements);
         bundleOperators.forEach((op) => {

package/lib/ocm/components/clusterConfiguration/review/ReviewNetworkingTable.tsx

@@ -8,6 +8,7 @@ import {
   useTranslation,
 } from '../../../../common';
 import { getManagementType, getStackTypeLabel } from './utils';
+import { useFeature } from '../../../hooks/use-feature';
 import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
 
 type ReviewTableRowsType = {
@@ -17,6 +18,7 @@ type ReviewTableRowsType = {
 
 export const ReviewNetworkingTable = ({ cluster }: { cluster: Cluster }) => {
   const { t } = useTranslation();
+  const isSingleClusterFeature = useFeature('ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE');
   const rows = React.useMemo(() => {
     const networkRows = [
       {
@@ -34,7 +36,7 @@ export const ReviewNetworkingTable = ({ cluster }: { cluster: Cluster }) => {
         cells: [
           { title: 'Stack type', colSpan: 2 },
           {
-            title: getStackTypeLabel(cluster),
+            title: getStackTypeLabel(cluster, isSingleClusterFeature),
             props: { 'data-testid': 'stack-type', colSpan: 2 },
           },
         ],
@@ -125,7 +127,7 @@ export const ReviewNetworkingTable = ({ cluster }: { cluster: Cluster }) => {
       });
 
     return networkRows;
-  }, [cluster]);
+  }, [cluster, isSingleClusterFeature]);
 
   const rowsAdvanced = React.useMemo(() => {
     return [