@openshift-assisted/ui-lib 2.46.3 → 2.47.1

package/lib/common/components/clusterConfiguration/utils.test.ts

@@ -0,0 +1,275 @@
+import { test, describe, expect } from 'vitest';
+import { isDualStack } from './utils';
+import {
+  MachineNetwork,
+  ClusterNetwork,
+  ServiceNetwork,
+} from '@openshift-assisted/types/assisted-installer-service';
+
+describe('isDualStack', () => {
+  const createMachineNetwork = (cidr: string): MachineNetwork => ({ cidr, clusterId: 'test' });
+  const createClusterNetwork = (cidr: string, hostPrefix: number): ClusterNetwork => ({
+    cidr,
+    hostPrefix,
+    clusterId: 'test',
+  });
+  const createServiceNetwork = (cidr: string): ServiceNetwork => ({ cidr, clusterId: 'test' });
+
+  describe('OCP < 4.12 (legacy behavior)', () => {
+    test('returns true for valid dual stack with IPv4 primary', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          createMachineNetwork('192.168.1.0/24'),
+          createMachineNetwork('2001:db8::/64'),
+        ],
+        clusterNetworks: [
+          createClusterNetwork('10.128.0.0/14', 23),
+          createClusterNetwork('fd01::/48', 64),
+        ],
+        serviceNetworks: [
+          createServiceNetwork('172.30.0.0/16'),
+          createServiceNetwork('fd02::/112'),
+        ],
+        openshiftVersion: '4.11',
+      });
+
+      expect(result).toBe(true);
+    });
+
+    test('returns false for IPv6 primary in OCP < 4.12', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          createMachineNetwork('2001:db8::/64'),
+          createMachineNetwork('192.168.1.0/24'),
+        ],
+        clusterNetworks: [
+          createClusterNetwork('fd01::/48', 64),
+          createClusterNetwork('10.128.0.0/14', 23),
+        ],
+        serviceNetworks: [
+          createServiceNetwork('fd02::/112'),
+          createServiceNetwork('172.30.0.0/16'),
+        ],
+        openshiftVersion: '4.11',
+      });
+
+      expect(result).toBe(false);
+    });
+
+    test('returns false for single stack', () => {
+      const result = isDualStack({
+        machineNetworks: [createMachineNetwork('192.168.1.0/24')],
+        clusterNetworks: [createClusterNetwork('10.128.0.0/14', 23)],
+        serviceNetworks: [createServiceNetwork('172.30.0.0/16')],
+        openshiftVersion: '4.11',
+      });
+
+      expect(result).toBe(false);
+    });
+
+    test('returns false for empty networks', () => {
+      const result = isDualStack({
+        machineNetworks: [],
+        clusterNetworks: [],
+        serviceNetworks: [],
+        openshiftVersion: '4.11',
+      });
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('OCP >= 4.12 (new behavior)', () => {
+    test('returns true for IPv4 primary and IPv6 secondary', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          createMachineNetwork('192.168.1.0/24'),
+          createMachineNetwork('2001:db8::/64'),
+        ],
+        clusterNetworks: [
+          createClusterNetwork('10.128.0.0/14', 23),
+          createClusterNetwork('fd01::/48', 64),
+        ],
+        serviceNetworks: [
+          createServiceNetwork('172.30.0.0/16'),
+          createServiceNetwork('fd02::/112'),
+        ],
+        openshiftVersion: '4.12',
+      });
+
+      expect(result).toBe(true);
+    });
+
+    test('returns true for IPv6 primary and IPv4 secondary', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          createMachineNetwork('2001:db8::/64'),
+          createMachineNetwork('192.168.1.0/24'),
+        ],
+        clusterNetworks: [
+          createClusterNetwork('fd01::/48', 64),
+          createClusterNetwork('10.128.0.0/14', 23),
+        ],
+        serviceNetworks: [
+          createServiceNetwork('fd02::/112'),
+          createServiceNetwork('172.30.0.0/16'),
+        ],
+        openshiftVersion: '4.12',
+      });
+
+      expect(result).toBe(true);
+    });
+
+    test('returns false for IPv6 primary and IPv6 secondary (not dual-stack)', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          createMachineNetwork('2001:db8::/64'),
+          createMachineNetwork('2001:db9::/64'),
+        ],
+        clusterNetworks: [
+          createClusterNetwork('fd01::/48', 64),
+          createClusterNetwork('fd02::/48', 64),
+        ],
+        serviceNetworks: [createServiceNetwork('fd03::/112'), createServiceNetwork('fd04::/112')],
+        openshiftVersion: '4.12',
+      });
+
+      expect(result).toBe(false);
+    });
+
+    test('returns false for IPv4 primary and IPv4 secondary (not dual-stack)', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          createMachineNetwork('192.168.1.0/24'),
+          createMachineNetwork('10.0.0.0/24'),
+        ],
+        clusterNetworks: [
+          createClusterNetwork('10.128.0.0/14', 23),
+          createClusterNetwork('172.16.0.0/14', 23),
+        ],
+        serviceNetworks: [
+          createServiceNetwork('172.30.0.0/16'),
+          createServiceNetwork('172.31.0.0/16'),
+        ],
+        openshiftVersion: '4.12',
+      });
+
+      expect(result).toBe(false);
+    });
+
+    test('returns false for single stack', () => {
+      const result = isDualStack({
+        machineNetworks: [createMachineNetwork('192.168.1.0/24')],
+        clusterNetworks: [createClusterNetwork('10.128.0.0/14', 23)],
+        serviceNetworks: [createServiceNetwork('172.30.0.0/16')],
+        openshiftVersion: '4.12',
+      });
+
+      expect(result).toBe(false);
+    });
+
+    test('returns false if any network type is not dual stack', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          createMachineNetwork('192.168.1.0/24'),
+          createMachineNetwork('2001:db8::/64'),
+        ],
+        clusterNetworks: [createClusterNetwork('10.128.0.0/14', 23)], // Single stack
+        serviceNetworks: [
+          createServiceNetwork('172.30.0.0/16'),
+          createServiceNetwork('fd02::/112'),
+        ],
+        openshiftVersion: '4.12',
+      });
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('no version specified (defaults to legacy behavior)', () => {
+    test('returns true for IPv4 primary and IPv6 secondary', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          createMachineNetwork('192.168.1.0/24'),
+          createMachineNetwork('2001:db8::/64'),
+        ],
+        clusterNetworks: [
+          createClusterNetwork('10.128.0.0/14', 23),
+          createClusterNetwork('fd01::/48', 64),
+        ],
+        serviceNetworks: [
+          createServiceNetwork('172.30.0.0/16'),
+          createServiceNetwork('fd02::/112'),
+        ],
+      });
+
+      expect(result).toBe(true);
+    });
+
+    test('returns false for IPv6 primary when no version specified', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          createMachineNetwork('2001:db8::/64'),
+          createMachineNetwork('192.168.1.0/24'),
+        ],
+        clusterNetworks: [
+          createClusterNetwork('fd01::/48', 64),
+          createClusterNetwork('10.128.0.0/14', 23),
+        ],
+        serviceNetworks: [
+          createServiceNetwork('fd02::/112'),
+          createServiceNetwork('172.30.0.0/16'),
+        ],
+      });
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    test('handles undefined networks', () => {
+      const result = isDualStack({
+        machineNetworks: undefined,
+        clusterNetworks: undefined,
+        serviceNetworks: undefined,
+        openshiftVersion: '4.12',
+      });
+
+      expect(result).toBe(false);
+    });
+
+    test('handles networks with empty CIDRs', () => {
+      const result = isDualStack({
+        machineNetworks: [
+          { cidr: '', clusterId: 'test' },
+          { cidr: '', clusterId: 'test' },
+        ],
+        clusterNetworks: [
+          { cidr: '', hostPrefix: 23, clusterId: 'test' },
+          { cidr: '', hostPrefix: 64, clusterId: 'test' },
+        ],
+        serviceNetworks: [
+          { cidr: '', clusterId: 'test' },
+          { cidr: '', clusterId: 'test' },
+        ],
+        openshiftVersion: '4.12',
+      });
+
+      expect(result).toBe(false);
+    });
+
+    test('handles invalid CIDRs', () => {
+      const result = isDualStack({
+        machineNetworks: [createMachineNetwork('invalid'), createMachineNetwork('also-invalid')],
+        clusterNetworks: [
+          createClusterNetwork('invalid', 23),
+          createClusterNetwork('also-invalid', 64),
+        ],
+        serviceNetworks: [createServiceNetwork('invalid'), createServiceNetwork('also-invalid')],
+        openshiftVersion: '4.12',
+      });
+
+      expect(result).toBe(false);
+    });
+  });
+});

package/lib/common/components/clusterConfiguration/utils.ts

@@ -10,6 +10,7 @@ import {
   ServiceNetwork,
 } from '@openshift-assisted/types/assisted-installer-service';
 import { NO_SUBNET_SET } from '../../config';
+import { isMajorMinorVersionEqualOrGreater } from '../../utils';
 import {
   selectClusterNetworkCIDR,
   selectClusterNetworkHostPrefix,
@@ -179,20 +180,38 @@ export const canBeDualStack = (subnets: HostSubnets) =>
 
 const areNetworksDualStack = (
   networks: (MachineNetwork | ClusterNetwork | ServiceNetwork)[] | undefined,
-) =>
-  networks &&
-  networks.length > 1 &&
-  Address4.isValid(networks[0].cidr || '') &&
-  Address6.isValid(networks[1].cidr || '');
+  openshiftVersion?: string,
+) => {
+  if (!networks || networks.length < 2) {
+    return false;
+  }
+
+  const firstCidr = networks[0].cidr || '';
+  const secondCidr = networks[1].cidr || '';
+
+  // For OCP >= 4.12, allow either IPv4 or IPv6 as primary, with opposite as secondary
+  if (openshiftVersion && isMajorMinorVersionEqualOrGreater(openshiftVersion, '4.12')) {
+    return (
+      (Address4.isValid(firstCidr) && Address6.isValid(secondCidr)) ||
+      (Address6.isValid(firstCidr) && Address4.isValid(secondCidr))
+    );
+  }
+
+  // For older versions, require IPv4 as primary and IPv6 as secondary
+  return Address4.isValid(firstCidr) && Address6.isValid(secondCidr);
+};
 
 export const isDualStack = ({
   machineNetworks,
   clusterNetworks,
   serviceNetworks,
-}: Pick<Cluster, 'machineNetworks' | 'clusterNetworks' | 'serviceNetworks'>) =>
-  areNetworksDualStack(machineNetworks) &&
-  areNetworksDualStack(clusterNetworks) &&
-  areNetworksDualStack(serviceNetworks);
+  openshiftVersion,
+}: Pick<Cluster, 'machineNetworks' | 'clusterNetworks' | 'serviceNetworks'> & {
+  openshiftVersion?: string;
+}) =>
+  areNetworksDualStack(machineNetworks, openshiftVersion) &&
+  areNetworksDualStack(clusterNetworks, openshiftVersion) &&
+  areNetworksDualStack(serviceNetworks, openshiftVersion);
 
 export const isSubnetInIPv6 = ({
   clusterNetworkCidr,

package/lib/common/components/clusterWizard/clusterDetailsValidation.ts

@@ -75,7 +75,7 @@ export const getClusterDetailsInitialValues = ({
     diskEncryptionTangServers: parseTangServers(cluster?.diskEncryption?.tangServers),
     diskEncryption: cluster?.diskEncryption ?? {},
     cpuArchitecture: cluster?.cpuArchitecture || getDefaultCpuArchitecture(),
-    platform: cluster?.platform?.type || 'none',
+    platform: cluster?.platform?.type || 'baremetal',
     customOpenshiftSelect: null,
     userManagedNetworking: cluster?.userManagedNetworking || false,
     enableDiskEncryptionOnArbiters: ['all', 'arbiters'].includes(

package/lib/common/components/ui/formik/_validationSchemas.test.ts

@@ -2,6 +2,7 @@ import { test, describe, expect } from 'vitest';
 import {
   baseDomainValidationSchema,
   dnsNameValidationSchema,
+  dualStackValidationSchema,
   hostPrefixValidationSchema,
   ipBlockValidationSchema,
   ipValidationSchema,
@@ -347,4 +348,85 @@ describe('validationSchemas', () => {
 
     expect(counter).toBe(invalid.length);
   });
+
+  describe('dualStackValidationSchema', () => {
+    describe('OCP < 4.12 (legacy behavior)', () => {
+      const schema = dualStackValidationSchema('machine networks', '4.11');
+
+      test('validates IPv4 as primary and IPv6 as secondary', async () => {
+        const validValues = [[{ cidr: '192.168.1.0/24' }, { cidr: '2001:db8::/64' }]];
+
+        for (const value of validValues) {
+          await expect(schema.validate(value)).resolves.toBe(value);
+        }
+      });
+
+      test('rejects IPv6 as primary for OCP < 4.12', async () => {
+        const invalidValues = [[{ cidr: '2001:db8::/64' }, { cidr: '192.168.1.0/24' }]];
+
+        for (const value of invalidValues) {
+          await expect(schema.validate(value)).rejects.toThrow(
+            'First network has to be IPv4 subnet',
+          );
+        }
+      });
+    });
+
+    describe('OCP >= 4.12 (new behavior)', () => {
+      const schema = dualStackValidationSchema('machine networks', '4.12');
+
+      test('validates IPv4 as primary and IPv6 as secondary', async () => {
+        const validValues = [[{ cidr: '192.168.1.0/24' }, { cidr: '2001:db8::/64' }]];
+
+        for (const value of validValues) {
+          await expect(schema.validate(value)).resolves.toBe(value);
+        }
+      });
+
+      test('validates IPv6 as primary and IPv4 as secondary', async () => {
+        const validValues = [[{ cidr: '2001:db8::/64' }, { cidr: '192.168.1.0/24' }]];
+
+        for (const value of validValues) {
+          await expect(schema.validate(value)).resolves.toBe(value);
+        }
+      });
+    });
+
+    describe('no version specified (defaults to legacy behavior)', () => {
+      const schema = dualStackValidationSchema('machine networks');
+
+      test('validates IPv4 as primary and IPv6 as secondary', async () => {
+        const validValues = [[{ cidr: '192.168.1.0/24' }, { cidr: '2001:db8::/64' }]];
+
+        for (const value of validValues) {
+          await expect(schema.validate(value)).resolves.toBe(value);
+        }
+      });
+
+      test('rejects IPv6 as primary when no version specified', async () => {
+        const invalidValues = [[{ cidr: '2001:db8::/64' }, { cidr: '192.168.1.0/24' }]];
+
+        for (const value of invalidValues) {
+          await expect(schema.validate(value)).rejects.toThrow(
+            'First network has to be IPv4 subnet',
+          );
+        }
+      });
+    });
+
+    describe('edge cases', () => {
+      test('validates maximum 2 networks', async () => {
+        const schema = dualStackValidationSchema('machine networks', '4.12');
+        const invalidValue = [
+          { cidr: '192.168.1.0/24' },
+          { cidr: '2001:db8::/64' },
+          { cidr: '10.0.0.0/24' },
+        ];
+
+        await expect(schema.validate(invalidValue)).rejects.toThrow(
+          'Maximum number of machine networks subnets in dual stack is 2',
+        );
+      });
+    });
+  });
 });

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

@@ -28,6 +28,7 @@ import {
   nameValidationMessages,
 } from './constants';
 import { allSubnetsIPv4, getAddress, trimCommaSeparatedList, trimSshPublicKey } from './utils';
+import { isMajorMinorVersionEqualOrGreater } from '../../../utils';
 import { selectApiVip, selectIngressVip } from '../../../selectors';
 import { ClusterDetailsValues } from '../../clusterWizard/types';
 
@@ -703,20 +704,25 @@ export const serviceNetworkValidationSchema = Yup.array().of(
   }),
 );
 
-export const dualStackValidationSchema = (field: string) =>
+export const dualStackValidationSchema = (field: string, openshiftVersion?: string) =>
   Yup.array()
     .max(2, `Maximum number of ${field} subnets in dual stack is 2.`)
     .test(
       'dual-stack-ipv4',
-      'First network has to be IPv4 subnet.',
-      (values?: { cidr: MachineNetwork['cidr'] }[]): boolean =>
-        !!values?.[0].cidr && Address4.isValid(values[0].cidr),
-    )
-    .test(
-      'dual-stack-ipv6',
-      'Second network has to be IPv6 subnet.',
-      (values?: { cidr: MachineNetwork['cidr'] }[]): boolean =>
-        !!values?.[1].cidr && Address6.isValid(values[1].cidr),
+      openshiftVersion && isMajorMinorVersionEqualOrGreater(openshiftVersion, '4.12')
+        ? 'First network has to be a valid IPv4 or IPv6 subnet.'
+        : 'First network has to be IPv4 subnet.',
+      (values?: { cidr: MachineNetwork['cidr'] }[]): boolean => {
+        // For OCP versions > 4.11, allow IPv6 as primary network
+        if (openshiftVersion && isMajorMinorVersionEqualOrGreater(openshiftVersion, '4.12')) {
+          return (
+            !!values?.[0].cidr &&
+            (Address4.isValid(values[0].cidr) || Address6.isValid(values[0].cidr))
+          );
+        }
+        // For older versions, require IPv4 as primary network
+        return !!values?.[0].cidr && Address4.isValid(values[0].cidr);
+      },
     );
 
 export const IPv4ValidationSchema = Yup.array().test(

package/lib/common/config/constants.ts

@@ -5,12 +5,10 @@ import {
   ClusterValidationId,
   DiskRole,
   Event,
-  HostRoleUpdateParams,
   HostValidationId,
 } from '@openshift-assisted/types/assisted-installer-service';
 import { ValidationGroup as ClusterValidationGroup } from '../types/clusters';
 import buildManifest from '@openshift-assisted/ui-lib/package.json';
-import { isInOcm } from '../api/axiosClient';
 
 export const DEFAULT_POLLING_INTERVAL = 10 * 1000;
 export const REDUCED_POLLING_INTERVAL = 10 * 1000 * 6;
@@ -35,15 +33,11 @@ export const hostRoles = (t: TFunction): HostRole[] => [
       'ai:Runs application workloads. Connect at least 5 hosts to enable dedicated workers.',
     ),
   },
-  ...(isInOcm
-    ? [
-        {
-          value: 'arbiter' as HostRoleUpdateParams,
-          label: t('ai:Arbiter'),
-          description: t('ai:Prevents split-brain scenarios and maintains quorum.'),
-        },
-      ]
-    : []),
+  {
+    value: 'arbiter',
+    label: t('ai:Arbiter'),
+    description: t('ai:Prevents split-brain scenarios and maintains quorum.'),
+  },
 ];
 
 export const clusterStatusLabels = (t: TFunction): { [key in Cluster['status']]: string } => ({

package/lib/ocm/components/clusterConfiguration/ControlPlaneNodesDropdown.tsx

@@ -17,7 +17,7 @@ import {
   useNewFeatureSupportLevel,
 } from '../../../common/components/newFeatureSupportLevels';
 import { isFeatureSupportedAndAvailable } from '../featureSupportLevels/featureStateUtils';
-import OcmTNADisclaimer from './OcmTNADisclaimer';
+import OcmTNADisclaimer from '../../../common/components/clusterConfiguration/OcmTNADisclaimer';
 import OcmSNODisclaimer from './OcmSNODisclaimer';
 
 const INPUT_NAME = 'controlPlaneCount';

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

@@ -1,6 +1,6 @@
 import React from 'react';
 import { Language } from '@patternfly/react-code-editor';
-import { ExpandableSection, Grid, GridItem, TextInput } from '@patternfly/react-core';
+import { ExpandableSection, Grid, GridItem } from '@patternfly/react-core';
 import { useField } from 'formik';
 import { OcmInputField, OcmCodeField } from '../../../ui/OcmFormFields';
 import { CustomManifestValues } from '../data/dataTypes';
@@ -30,12 +30,6 @@ const ExpandedManifest = ({ fieldName, manifestIdx }: CustomManifestComponentPro
     >
       <Grid hasGutter span={12}>
         <GridItem span={6}>
-          <TextInput
-            hidden={true}
-            name={`${fieldName}.fakeId`}
-            data-testid={`fakeId-${manifestIdx}`}
-            id={`fakeId-${manifestIdx}`}
-          />
           <FolderDropdown name={`${fieldName}.folder`} data-testid={`folder-${manifestIdx}`} />
         </GridItem>
         <GridItem span={6}>

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

@@ -8,6 +8,7 @@ import {
   Grid,
 } from '@patternfly/react-core';
 import { FieldArray, useFormikContext } from 'formik';
+import { Address6 } from 'ip-address';
 import {
   DUAL_STACK,
   PREFIX_MAX_RESTRICTION,
@@ -16,10 +17,6 @@ import {
 } from '../../../../common';
 import { OcmInputField } from '../../ui/OcmFormFields';
 
-const getNetworkLabelSuffix = (index: number, isDualStack: boolean) => {
-  return isDualStack ? ` (${index === 0 ? 'IPv4' : 'IPv6'})` : '';
-};
-
 const IPv4PrefixPopoverText =
   'For example, if Cluster Network Host Prefix is set to 23, then each node is assigned a /23 subnet out of the given cidr (clusterNetworkCIDR), which allows for 510 (2^(32 - 23) - 2) pod IPs addresses.';
 
@@ -36,10 +33,62 @@ const serviceCidrHelperText =
   'Enter only 1 IP address pool. If you need to access the services from an external network, configure load balancers and routers to manage the traffic.';
 
 const AdvancedNetworkFields = () => {
-  const { values, errors } = useFormikContext<NetworkConfigurationValues>();
+  const { values, errors, setFieldValue } = useFormikContext<NetworkConfigurationValues>();
 
   const isDualStack = values.stackType === DUAL_STACK;
 
+  // Reorder Cluster Networks and Service Networks when Machine Network primary changes
+  React.useEffect(() => {
+    if (!isDualStack || !values.machineNetworks?.[0]?.cidr) return;
+
+    const primaryMachineNetworkCidr = values.machineNetworks[0].cidr;
+    const isPrimaryIPv6 = Address6.isValid(primaryMachineNetworkCidr);
+
+    // Check Cluster Networks
+    if (values.clusterNetworks && values.clusterNetworks.length >= 2) {
+      const firstClusterCidr = values.clusterNetworks[0].cidr;
+      if (!firstClusterCidr) return;
+
+      const isFirstClusterIPv6 = Address6.isValid(firstClusterCidr);
+
+      // If primary machine is IPv6 but first cluster is IPv4, swap them
+      if (isPrimaryIPv6 && !isFirstClusterIPv6) {
+        const reordered = [values.clusterNetworks[1], values.clusterNetworks[0]];
+        setFieldValue('clusterNetworks', reordered, false);
+      }
+      // If primary machine is IPv4 but first cluster is IPv6, swap them
+      else if (!isPrimaryIPv6 && isFirstClusterIPv6) {
+        const reordered = [values.clusterNetworks[1], values.clusterNetworks[0]];
+        setFieldValue('clusterNetworks', reordered, false);
+      }
+    }
+
+    // Check Service Networks
+    if (values.serviceNetworks && values.serviceNetworks.length >= 2) {
+      const firstServiceCidr = values.serviceNetworks[0].cidr;
+      if (!firstServiceCidr) return;
+
+      const isFirstServiceIPv6 = Address6.isValid(firstServiceCidr);
+
+      // If primary machine is IPv6 but first service is IPv4, swap them
+      if (isPrimaryIPv6 && !isFirstServiceIPv6) {
+        const reordered = [values.serviceNetworks[1], values.serviceNetworks[0]];
+        setFieldValue('serviceNetworks', reordered, false);
+      }
+      // If primary machine is IPv4 but first service is IPv6, swap them
+      else if (!isPrimaryIPv6 && isFirstServiceIPv6) {
+        const reordered = [values.serviceNetworks[1], values.serviceNetworks[0]];
+        setFieldValue('serviceNetworks', reordered, false);
+      }
+    }
+  }, [
+    isDualStack,
+    values.machineNetworks,
+    values.clusterNetworks,
+    values.serviceNetworks,
+    setFieldValue,
+  ]);
+
   const clusterNetworkCidrPrefix = (index: number) =>
     parseInt(
       ((values.clusterNetworks && values.clusterNetworks[index].cidr) || '').split('/')[1],
@@ -66,7 +115,6 @@ const AdvancedNetworkFields = () => {
         {() => (
           <FormGroup fieldId="clusterNetworks" labelInfo={isDualStack && 'Primary'}>
             {values.clusterNetworks?.map((_, index) => {
-              const networkSuffix = getNetworkLabelSuffix(index, isDualStack);
               return (
                 <Grid key={index} className="pf-v6-u-pb-md">
                   <GridItem className={'network-field-group'}>
@@ -74,7 +122,7 @@ const AdvancedNetworkFields = () => {
                       name={`clusterNetworks.${index}.cidr`}
                       label={
                         <>
-                          <span>{`Cluster network CIDR${networkSuffix} `}</span>
+                          <span>Cluster network CIDR </span>
                           <PopoverIcon
                             bodyContent={'IP address blocks from which Pod IPs are allocated.'}
                           />
@@ -82,7 +130,7 @@ const AdvancedNetworkFields = () => {
                       }
                       helperText={clusterCidrHelperText}
                       isRequired
-                      labelInfo={index === 0 && isDualStack ? 'Primary' : ''}
+                      labelInfo={isDualStack ? (index === 0 ? 'Primary' : 'Secondary') : ''}
                     />
                   </GridItem>
                   <GridItem className={'network-field-group'}>
@@ -90,7 +138,7 @@ const AdvancedNetworkFields = () => {
                       name={`clusterNetworks.${index}.hostPrefix`}
                       label={
                         <>
-                          <span>Cluster network host prefix{networkSuffix} </span>
+                          <span>Cluster network host prefix </span>
                           <PopoverIcon
                             bodyContent={clusterNetworkHostPrefixPopoverText(index)}
                             minWidth="30rem"
@@ -128,9 +176,7 @@ const AdvancedNetworkFields = () => {
                   name={`serviceNetworks.${index}.cidr`}
                   label={
                     <>
-                      <span>
-                        {`Service network CIDR${getNetworkLabelSuffix(index, isDualStack)} `}
-                      </span>
+                      <span>Service network CIDR </span>
                       <PopoverIcon
                         bodyContent={'The IP address pool used for service IP addresses.'}
                       />
@@ -138,7 +184,7 @@ const AdvancedNetworkFields = () => {
                   }
                   helperText={serviceCidrHelperText}
                   isRequired
-                  labelInfo={index === 0 && isDualStack ? 'Primary' : ''}
+                  labelInfo={isDualStack ? (index === 0 ? 'Primary' : 'Secondary') : ''}
                 />
               </GridItem>
             ))}