@openshift-assisted/ui-lib 2.17.4-cim → 2.17.6-cim

package/lib/common/components/clusterWizard/networkingSteps/StackTypeControlGroup.tsx

@@ -7,13 +7,14 @@ import { HostSubnets, NetworkConfigurationValues } from '../../../types';
 import { getFieldId } from '../../ui';
 import {
   DUAL_STACK,
-  IPV4_STACK,
+  NO_SUBNET_SET,
+  SINGLE_STACK,
   NETWORK_TYPE_OVN,
   NETWORK_TYPE_SDN,
-  NO_SUBNET_SET,
 } from '../../../config';
 import { RadioField } from '../../ui/formik';
 import { ConfirmationModal, PopoverIcon } from '../../ui';
+import { useTranslation } from '../../../hooks/use-translation-wrapper';
 import { reorderNetworksByCurrentPrimary } from './reorderNetworks';
 import {
   Cluster,
@@ -37,6 +38,7 @@ export type StackTypeControlGroupProps = {
   hostSubnets: HostSubnets;
   defaultNetworkValues: StackTypeDefaultNetworkValues;
   isViewerMode?: boolean;
+  allowSingleStackIPv6?: boolean;
 };
 
 const hasDualStackConfigurationChanged = (
@@ -61,17 +63,21 @@ export const StackTypeControlGroup = ({
   hostSubnets,
   defaultNetworkValues,
   isViewerMode = false,
+  allowSingleStackIPv6 = false,
 }: StackTypeControlGroupProps) => {
+  const { t } = useTranslation();
   const { setFieldValue, values, validateForm } = useFormikContext<NetworkConfigurationValues>();
   const [openConfirmModal, setConfirmModal] = React.useState(false);
 
+  const singleStackLabel = allowSingleStackIPv6 ? t('ai:Single stack') : t('ai:IPv4');
+
   const IPv6Subnets = hostSubnets.filter((subnet) => Address6.isValid(subnet.subnet));
   const cidrIPv6 = IPv6Subnets.length >= 1 ? IPv6Subnets[0].subnet : NO_SUBNET_SET;
   const shouldSetSingleStack =
     !isViewerMode && !isDualStackSelectable && values.stackType === DUAL_STACK;
 
   const setSingleStack = React.useCallback(() => {
-    setFieldValue('stackType', IPV4_STACK);
+    setFieldValue('stackType', SINGLE_STACK);
 
     // Determine whether the first machine network is IPv4
     const firstNetwork = values.machineNetworks?.[0];
@@ -95,7 +101,8 @@ export const StackTypeControlGroup = ({
         }
       }
     }
-    // Ensure single-stack inputs are IPv4 after switching from dual-stack
+
+    // Set cluster/service to IPv4 defaults when switching to single-stack
     if (values.clusterNetworks && values.clusterNetworks.length >= 1) {
       const defaultCluster =
         defaultNetworkValues.clusterNetworksIpv4 && defaultNetworkValues.clusterNetworksIpv4[0];
@@ -197,28 +204,27 @@ export const StackTypeControlGroup = ({
       }
     }
     if (values.clusterNetworks && values.clusterNetworks?.length < 2) {
-      setFieldValue(
-        'clusterNetworks',
-        [
-          ...values.clusterNetworks,
-          defaultNetworkValues.clusterNetworksDualstack?.length
-            ? defaultNetworkValues.clusterNetworksDualstack[1]
-            : { cidr: '', hostPrefix: '', clusterId: clusterId },
-        ],
-        false,
-      );
+      const firstClusterCidr = values.clusterNetworks[0]?.cidr;
+      const isPrimaryIPv6 = firstClusterCidr && Address6.isValid(firstClusterCidr);
+      const missingFamilyNetworkDefault =
+        defaultNetworkValues.clusterNetworksDualstack?.[isPrimaryIPv6 ? 0 : 1];
+      const secondClusterNetwork = missingFamilyNetworkDefault ?? {
+        cidr: '',
+        hostPrefix: '',
+        clusterId: clusterId,
+      };
+      setFieldValue('clusterNetworks', [...values.clusterNetworks, secondClusterNetwork], false);
     }
     if (values.serviceNetworks && values.serviceNetworks?.length < 2) {
-      setFieldValue(
-        'serviceNetworks',
-        [
-          ...values.serviceNetworks,
-          defaultNetworkValues.serviceNetworksDualstack?.length
-            ? defaultNetworkValues.serviceNetworksDualstack[1]
-            : { cidr: '', clusterId: clusterId },
-        ],
-        false,
-      );
+      const firstServiceCidr = values.serviceNetworks[0]?.cidr;
+      const isPrimaryIPv6 = firstServiceCidr && Address6.isValid(firstServiceCidr);
+      const missingFamilyNetworkDefault =
+        defaultNetworkValues.serviceNetworksDualstack?.[isPrimaryIPv6 ? 0 : 1];
+      const secondServiceNetwork = missingFamilyNetworkDefault ?? {
+        cidr: '',
+        clusterId: clusterId,
+      };
+      setFieldValue('serviceNetworks', [...values.serviceNetworks, secondServiceNetwork], false);
     }
     // Initialize VIPs for dual-stack
     if (values.apiVips && values.apiVips.length < 2) {
@@ -291,14 +297,18 @@ export const StackTypeControlGroup = ({
           <SplitItem>
             <RadioField
               name={'stackType'}
-              value={IPV4_STACK}
+              value={SINGLE_STACK}
               isDisabled={!isDualStackSelectable || isViewerMode}
-              label="IPv4&nbsp;"
+              label={`${singleStackLabel}\u00A0`}
             />
           </SplitItem>
           <SplitItem>
             <PopoverIcon
-              bodyContent="Select this when your hosts are using only IPv4."
+              bodyContent={
+                allowSingleStackIPv6
+                  ? t('ai:Select a single address family (IPv4 or IPv6) for your machine network.')
+                  : t('ai:Select this when your hosts are using only IPv4.')
+              }
               buttonStyle={{ top: '-4px' }}
             />
           </SplitItem>

package/lib/common/components/ui/formik/utils.ts

@@ -126,6 +126,12 @@ export const allSubnetsIPv4 = (
   return !!networks?.every((network) => network.cidr && Address4.isValid(network.cidr));
 };
 
+export const allSubnetsIPv6 = (
+  networks: (MachineNetwork | ClusterNetwork | ServiceNetwork)[] | undefined,
+) => {
+  return !!networks?.every((network) => network.cidr && Address6.isValid(network.cidr));
+};
+
 export const labelsToArray = (labels: { [key in string]: string } = {}): string[] => {
   const result: string[] = [];
   for (const key in labels) {

package/lib/common/config/constants.ts

@@ -287,8 +287,10 @@ export const CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV6 = {
 export const CLUSTER_DEFAULT_NETWORK_SETTINGS: Pick<
   ClusterDefaultConfig,
   | 'clusterNetworksIpv4'
+  | 'clusterNetworksIpv6'
   | 'clusterNetworksDualstack'
   | 'serviceNetworksIpv4'
+  | 'serviceNetworksIpv6'
   | 'serviceNetworksDualstack'
 > = {
   clusterNetworksIpv4: [
@@ -297,6 +299,12 @@ export const CLUSTER_DEFAULT_NETWORK_SETTINGS: Pick<
       hostPrefix: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.clusterNetworkHostPrefix,
     },
   ],
+  clusterNetworksIpv6: [
+    {
+      cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV6.clusterNetworkCidr,
+      hostPrefix: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV6.clusterNetworkHostPrefix,
+    },
+  ],
   clusterNetworksDualstack: [
     {
       cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.clusterNetworkCidr,
@@ -308,6 +316,7 @@ export const CLUSTER_DEFAULT_NETWORK_SETTINGS: Pick<
     },
   ],
   serviceNetworksIpv4: [{ cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.serviceNetworkCidr }],
+  serviceNetworksIpv6: [{ cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV6.serviceNetworkCidr }],
   serviceNetworksDualstack: [
     { cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.serviceNetworkCidr },
     { cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV6.serviceNetworkCidr },
@@ -334,7 +343,7 @@ export const NO_SUBNET_SET = 'NO_SUBNET_SET';
 export const NETWORK_TYPE_OVN = 'OVNKubernetes';
 export const NETWORK_TYPE_SDN = 'OpenShiftSDN';
 
-export const IPV4_STACK = 'singleStack';
+export const SINGLE_STACK = 'singleStack';
 export const DUAL_STACK = 'dualStack';
 
 export const PREFIX_MAX_RESTRICTION = {

package/lib/common/validationSchemas/networkingValidation.tsx

@@ -13,7 +13,8 @@ import {
   ipBlockValidationSchema,
 } from './addressValidation';
 import { isMajorMinorVersionEqualOrGreater } from '../utils';
-import { allSubnetsIPv4 } from '../components/ui/formik/utils';
+import { allSubnetsIPv4, allSubnetsIPv6 } from '../components/ui/formik/utils';
+import { SINGLE_STACK } from '../config';
 
 export const machineNetworksValidationSchema = Yup.array().of(
   Yup.object({ cidr: hostSubnetValidationSchema, clusterId: Yup.string() }),
@@ -111,3 +112,40 @@ export const IPv4ValidationSchema = Yup.array().test(
   `All network subnets must be IPv4.`,
   (values?: (MachineNetwork | ClusterNetwork | ServiceNetwork)[]) => allSubnetsIPv4(values),
 );
+
+export const IPv6ValidationSchema = Yup.array().test(
+  'single-stack-ipv6',
+  'All network subnets must be IPv6.',
+  (values?: (MachineNetwork | ClusterNetwork | ServiceNetwork)[]) => allSubnetsIPv6(values),
+);
+
+export const clusterNetworksSchema = (
+  t: TFunction,
+  stackType: string,
+  primaryCidr: string | undefined,
+  openshiftVersion?: string,
+) => {
+  const singleStackFamilySchema =
+    primaryCidr && isCIDR.v6(primaryCidr) ? IPv6ValidationSchema : IPv4ValidationSchema;
+
+  const stackFamilySchema =
+    stackType === SINGLE_STACK
+      ? singleStackFamilySchema
+      : dualStackValidationSchema(t('ai:cluster network'), t, openshiftVersion);
+  return clusterNetworksValidationSchema(t).concat(stackFamilySchema);
+};
+
+export const serviceNetworksSchema = (
+  t: TFunction,
+  stackType: string,
+  primaryCidr: string | undefined,
+  openshiftVersion?: string,
+) => {
+  const singleStackFamilySchema =
+    primaryCidr && isCIDR.v6(primaryCidr) ? IPv6ValidationSchema : IPv4ValidationSchema;
+  const stackFamilySchema =
+    stackType === SINGLE_STACK
+      ? singleStackFamilySchema
+      : dualStackValidationSchema(t('ai:service network'), t, openshiftVersion);
+  return serviceNetworkValidationSchema(t).concat(stackFamilySchema);
+};

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

@@ -9,7 +9,7 @@ import {
   getFormikErrorFields,
   getHostSubnets,
   HostSubnets,
-  IPV4_STACK,
+  SINGLE_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 === IPV4_STACK) {
+        } else if (values.stackType === SINGLE_STACK) {
           // The API will rebuild the default machineNetwork
           params.machineNetworks = [];
         }

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

@@ -11,7 +11,7 @@ import {
   serviceNetworkValidationSchema,
   IPv4ValidationSchema,
   sshPublicKeyValidationSchema,
-  IPV4_STACK,
+  SINGLE_STACK,
   DUAL_STACK,
   vipArrayValidationSchema,
   NETWORK_TYPE_OVN,
@@ -50,7 +50,7 @@ export const getNetworkInitialValues = (
         : 'clusterManaged',
     networkType: cluster.networkType || NETWORK_TYPE_OVN,
     machineNetworks: cluster.machineNetworks || [],
-    stackType: isDualStackType ? DUAL_STACK : IPV4_STACK,
+    stackType: isDualStackType ? DUAL_STACK : SINGLE_STACK,
     clusterNetworks:
       cluster.clusterNetworks ||
       (isDualStackType
@@ -85,7 +85,8 @@ export const getNetworkConfigurationValidationSchema = (
         values.managedNetworkingType === 'userManaged'
           ? Yup.array()
           : machineNetworksValidationSchema.when('stackType', {
-              is: (stackType: NetworkConfigurationValues['stackType']) => stackType === IPV4_STACK,
+              is: (stackType: NetworkConfigurationValues['stackType']) =>
+                stackType === SINGLE_STACK,
               then: () => machineNetworksValidationSchema.concat(IPv4ValidationSchema),
               otherwise: () =>
                 values.machineNetworks && values.machineNetworks?.length >= 2
@@ -95,13 +96,13 @@ export const getNetworkConfigurationValidationSchema = (
                   : Yup.array(),
             }),
       clusterNetworks: clusterNetworksValidationSchema(t).when('stackType', {
-        is: (stackType: NetworkConfigurationValues['stackType']) => stackType === IPV4_STACK,
+        is: (stackType: NetworkConfigurationValues['stackType']) => stackType === SINGLE_STACK,
         then: (schema) => schema.concat(IPv4ValidationSchema),
         otherwise: (schema) =>
           schema.concat(dualStackValidationSchema('cluster network', t, openshiftVersion)),
       }),
       serviceNetworks: serviceNetworkValidationSchema(t).when('stackType', {
-        is: (stackType: NetworkConfigurationValues['stackType']) => stackType === IPV4_STACK,
+        is: (stackType: NetworkConfigurationValues['stackType']) => stackType === SINGLE_STACK,
         then: (schema) => schema.concat(IPv4ValidationSchema),
         otherwise: (schema) =>
           schema.concat(dualStackValidationSchema('service network', t, openshiftVersion)),

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
-    "@openshift-assisted/locales": "2.17.4-cim",
-    "@openshift-assisted/types": "2.17.4-cim",
+    "@openshift-assisted/locales": "2.17.6-cim",
+    "@openshift-assisted/types": "2.17.6-cim",
     "@openshift-console/dynamic-plugin-sdk": "1.0.0",
     "@patternfly/patternfly": "6.2.3",
     "@patternfly/react-code-editor": "6.2.2",
@@ -140,5 +140,5 @@
       ]
     }
   },
-  "version": "2.17.4-cim"
+  "version": "2.17.6-cim"
 }