@openshift-assisted/ui-lib 2.16.5-cim → 2.17.1-cim

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

@@ -3,14 +3,11 @@ import { Address4, Address6 } from 'ip-address';
 import isCIDR from 'is-cidr';
 import { isInSubnet } from 'is-in-subnet';
 import * as Yup from 'yup';
-import { head } from 'lodash-es';
 import parseUrl from 'parse-url';
 
 import { TFunction } from 'i18next';
 import {
-  ApiVip,
   ClusterNetwork,
-  IngressVip,
   MachineNetwork,
   ServiceNetwork,
 } from '@openshift-assisted/types/assisted-installer-service';
@@ -28,7 +25,7 @@ import {
   nameValidationMessages,
 } from './constants';
 import { allSubnetsIPv4, getAddress, trimCommaSeparatedList, trimSshPublicKey } from './utils';
-import { selectApiVip, selectIngressVip } from '../../../selectors';
+import { isMajorMinorVersionEqualOrGreater } from '../../../utils';
 import { ClusterDetailsValues } from '../../clusterWizard/types';
 
 const ALPHANUMERIC_REGEX = /^[a-zA-Z0-9]+$/;
@@ -122,14 +119,12 @@ export const sshPublicKeyListValidationSchema = Yup.string()
       if (!value) {
         return true;
       }
-      return !!trimSshPublicKey(value).match(SSH_PUBLIC_KEY_REGEX);
-
-      // disable until mutliple keys are supported (https://issues.redhat.com/browse/METAL-250)
-      // return (
-      //   trimSshPublicKey(value)
-      //     .split('\n')
-      //     .find((line: string) => !line.match(SSH_PUBLIC_KEY_REGEX)) === undefined
-      // );
+
+      return (
+        trimSshPublicKey(value)
+          .split('\n')
+          .find((line: string) => !line.match(SSH_PUBLIC_KEY_REGEX)) === undefined
+      );
     },
   )
   .test('ssh-public-keys-unique', 'SSH public keys must be unique.', (value?: string) => {
@@ -172,6 +167,17 @@ export const ipValidationSchema = Yup.string().test(
   (value?: string) => Address4.isValid(value || '') || Address6.isValid(value || ''),
 );
 
+// Helpers to classify literal IPs more robustly
+const isIPv4Address = (ip?: string) => {
+  if (!ip) return false;
+  return ip.includes('.') && Address4.isValid(ip);
+};
+
+const isIPv6Address = (ip?: string) => {
+  if (!ip) return false;
+  return ip.includes(':') && Address6.isValid(ip);
+};
+
 export const ipNoSuffixValidationSchema = Yup.string().test(
   'ip-validation-no-suffix',
   'Not a valid IP address',
@@ -187,7 +193,7 @@ export const macAddressValidationSchema = Yup.string().matches(MAC_REGEX, {
 
 export const vipRangeValidationSchema = (
   hostSubnets: HostSubnets,
-  { machineNetworks, hostSubnet }: NetworkConfigurationValues,
+  { machineNetworks }: NetworkConfigurationValues,
   allowSuffix: boolean,
 ) =>
   Yup.string().test('vip-validation', 'IP Address is outside of selected subnet', (value) => {
@@ -201,18 +207,11 @@ export const vipRangeValidationSchema = (
     } catch (err) {
       return true;
     }
+    // Find host subnets that match the selected machine networks
+    const cidrs = machineNetworks?.map((network) => network.cidr) ?? [];
+    const matchingSubnets = hostSubnets.filter((hostSubnet) => cidrs.includes(hostSubnet.subnet));
 
-    const foundHostSubnets = [];
-    if (machineNetworks) {
-      const cidrs = machineNetworks?.map((network) => network.cidr);
-      foundHostSubnets.push(...hostSubnets.filter((hn) => cidrs?.includes(hn.subnet)));
-    } else {
-      const subnet = hostSubnets.find((hn) => hn.subnet === hostSubnet);
-      if (subnet) {
-        foundHostSubnets.push(subnet);
-      }
-    }
-    for (const hostSubnet of foundHostSubnets) {
+    for (const hostSubnet of matchingSubnets) {
       if (hostSubnet?.subnet) {
         // Workaround for bug in CIM backend. hostIDs are empty
         if (!hostSubnet.hostIDs.length) {
@@ -225,109 +224,143 @@ export const vipRangeValidationSchema = (
     return false;
   });
 
-const vipUniqueValidationSchema = (
-  { ingressVips, apiVips, apiVip, ingressVip }: NetworkConfigurationValues,
-  useIPArray: boolean,
-) =>
-  Yup.string().test(
-    'vip-uniqueness-validation',
-    'The Ingress and API IP addresses cannot be the same.',
-    (value) => {
-      if (useIPArray) {
-        if (!value || ingressVips?.length === 0 || apiVips?.length === 0) {
-          return true;
-        }
-        return selectApiVip({ apiVips }) !== selectIngressVip({ ingressVips });
-      } else {
-        if (!value) {
-          return true;
-        }
-        return apiVip !== ingressVip;
-      }
-    },
-  );
-
 const vipBroadcastValidationSchema = ({ machineNetworks }: NetworkConfigurationValues) =>
   Yup.string().test(
     'vip-no-broadcast',
     'The IP address cannot be a network or broadcast address',
-    (value?: string) => {
-      const vipAddress = getAddress(value || '')?.address;
-      const machineNetwork = getAddress((machineNetworks?.length && machineNetworks[0].cidr) || '');
+    function (value?: string) {
+      if (!value) {
+        return true;
+      }
 
-      const machineNetworkBroadcast = machineNetwork?.endAddress().address;
-      const machineNetworkAddress = machineNetwork?.startAddress().address;
+      const vipAddress = getAddress(value)?.address;
+      if (!vipAddress) {
+        return true;
+      }
+
+      const index = getArrayIndexFromPath(this.path || '');
+      const machineNetworkCidr = machineNetworks?.[index]?.cidr ?? machineNetworks?.[0]?.cidr ?? '';
+      if (!machineNetworkCidr) {
+        return true;
+      }
+
+      const machineNetwork = getAddress(machineNetworkCidr);
+      if (!machineNetwork) {
+        return true;
+      }
+
+      const machineNetworkBroadcast = machineNetwork.endAddress().address;
+      const machineNetworkAddress = machineNetwork.startAddress().address;
 
       return vipAddress !== machineNetworkBroadcast && vipAddress !== machineNetworkAddress;
     },
   );
 
-// like .required() but passes for initially empty field
-const requiredOnceSet = (initialValue?: string, message?: string) =>
+const alwaysRequired = (message?: string) =>
   Yup.string().test(
-    'required-once-set',
+    'always-required',
     message || 'The value is required.',
-    (value?: string): boolean => !!value || !initialValue,
+    (value?: string): boolean => !!value,
   );
 
+const getArrayIndexFromPath = (path: string): number => {
+  const match = path.match(/\[(\d+)\][^\[]*$/); // Prefer the last [...] occurrence for nested array paths like "foo[0].bar[1].ip"
+  return match ? parseInt(match[1], 10) : NaN;
+};
+
 export const hostSubnetValidationSchema = Yup.string().when(['managedNetworkingType'], {
   is: (managedNetworkingType: NetworkConfigurationValues['managedNetworkingType']) =>
     managedNetworkingType === 'clusterManaged',
   then: () => Yup.string().notOneOf([NO_SUBNET_SET], 'Host subnet must be selected.'),
 });
 
-export const vipValidationSchema = (
-  hostSubnets: HostSubnets,
-  values: NetworkConfigurationValues,
-  initialValue?: string,
-) =>
-  Yup.mixed().when(['vipDhcpAllocation', 'managedNetworkingType'], {
-    is: (
-      vipDhcpAllocation: NetworkConfigurationValues['vipDhcpAllocation'],
-      managedNetworkingType: NetworkConfigurationValues['managedNetworkingType'],
-    ) => !vipDhcpAllocation && managedNetworkingType !== 'userManaged',
-    then: () =>
-      requiredOnceSet(initialValue, 'Required. Please provide an IP address')
-        .concat(vipRangeValidationSchema(hostSubnets, values, true))
-        .concat(vipUniqueValidationSchema(values, false)),
-  });
-
 export const vipNoSuffixValidationSchema = (
   hostSubnets: HostSubnets,
   values: NetworkConfigurationValues,
-  initialValues?: ApiVip[] | IngressVip[],
 ) =>
   Yup.mixed().when(['vipDhcpAllocation', 'managedNetworkingType'], {
     is: (
       vipDhcpAllocation: NetworkConfigurationValues['vipDhcpAllocation'],
       managedNetworkingType: NetworkConfigurationValues['managedNetworkingType'],
     ) => !vipDhcpAllocation && managedNetworkingType !== 'userManaged',
-    then: () =>
-      requiredOnceSet(head(initialValues)?.ip, 'Required. Please provide an IP address')
+    then: () => {
+      // Per-item schema for VIPs (apiVips[*].ip / ingressVips[*].ip)
+      // 1) Require value once set
+      // 2) Validate IP without suffix
+      // 3) Ensure VIP family matches machineNetworks[idx] family
+      // 4) Validate range vs selected subnets
+      // 5) No broadcast/network address
+      // 6) Uniqueness across API/Ingress
+      const vipFamilyMatchSchema = Yup.string().test(
+        'vip-family-match-machine-network',
+        'IP family must match the corresponding machine network family.',
+        function (value?: string) {
+          if (!value) {
+            return true;
+          }
+          const index = getArrayIndexFromPath(this.path || '');
+          if (Number.isNaN(index)) {
+            return true;
+          }
+          const cidr = values.machineNetworks?.[index]?.cidr || '';
+          const mnIsV4 = isCIDR.v4(cidr);
+          const mnIsV6 = isCIDR.v6(cidr);
+          // If machine network at index is not selected/valid, don't block validation here
+          if (!mnIsV4 && !mnIsV6) {
+            return true;
+          }
+          const ipIsV4 = isIPv4Address(value);
+          const ipIsV6 = isIPv6Address(value);
+          if (!ipIsV4 && !ipIsV6) {
+            return true;
+          }
+          return mnIsV4 ? ipIsV4 : ipIsV6;
+        },
+      );
+      // Ensure API and Ingress VIPs at the same index are not the same
+      const vipUniqueSchema = Yup.string().test('vip-uniqueness', function (value?: string) {
+        if (!value) {
+          return true;
+        }
+        const index = getArrayIndexFromPath(this.path || '');
+        if (Number.isNaN(index)) {
+          return true;
+        }
+        const apiVip = values.apiVips?.[index]?.ip;
+        const ingressVip = values.ingressVips?.[index]?.ip;
+        if (!apiVip || !ingressVip) {
+          return true;
+        }
+        if (apiVip === ingressVip) {
+          const label = index === 0 ? 'primary' : 'secondary';
+          return this.createError({
+            message: `The ${label} Ingress and API IP addresses cannot be the same.`,
+          });
+        }
+        return true;
+      });
+
+      return alwaysRequired('Required. Please provide an IP address')
         .concat(ipNoSuffixValidationSchema)
+        .concat(vipFamilyMatchSchema)
         .concat(vipRangeValidationSchema(hostSubnets, values, false))
         .concat(vipBroadcastValidationSchema(values))
-        .concat(vipUniqueValidationSchema(values, true)),
+        .concat(vipUniqueSchema);
+    },
   });
 
 export const vipArrayValidationSchema = <T extends Yup.Maybe<Yup.AnyObject>>(
   hostSubnets: HostSubnets,
   values: NetworkConfigurationValues,
-  initialValues?: ApiVip[] | IngressVip[],
 ) =>
-  (values.managedNetworkingType === 'clusterManaged'
+  values.managedNetworkingType === 'clusterManaged'
     ? Yup.array<T>().of(
         Yup.object({
           clusterId: Yup.string(),
-          ip: vipNoSuffixValidationSchema(hostSubnets, values, initialValues),
+          ip: vipNoSuffixValidationSchema(hostSubnets, values),
         }),
       )
-    : Yup.array<T>()
-  ).test(
-    'vips-length',
-    'Both API and ingress APIs must be provided.',
-    (_value) => values.apiVips?.length === values.ingressVips?.length,
-  );
+    : Yup.array<T>();
 
 export const ipBlockValidationSchema = (reservedCidrs: string | string[] | undefined) =>
   Yup.string()
@@ -439,11 +472,11 @@ export const hostPrefixValidationSchema = (
   const errorMsgIPv4 = `${errorMsgPrefix} (${netBlockNumber}) and 25.`;
   const errorMsgIPv6 = `${errorMsgPrefix} (8) and 128.`;
 
-  if (Address6.isValid(clusterNetworkCidr || '')) {
+  if (isCIDR.v6(clusterNetworkCidr || '')) {
     return Yup.number().required(requiredText).min(8, errorMsgIPv6).max(128, errorMsgIPv6);
   }
 
-  if (Address4.isValid(clusterNetworkCidr || '')) {
+  if (isCIDR.v4(clusterNetworkCidr || '')) {
     return Yup.number()
       .required(requiredText)
       .min(netBlockNumber, errorMsgIPv4)
@@ -703,20 +736,64 @@ 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),
+      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 && (isCIDR.v4(values[0].cidr) || isCIDR.v6(values[0].cidr));
+        }
+        // For older versions, require IPv4 as primary network
+        return !!values?.[0].cidr && isCIDR.v4(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),
+      'dual-stack-unique-cidrs',
+      `Provided ${field} subnets must be unique.`,
+      (values?: { cidr?: MachineNetwork['cidr'] }[]) => {
+        if (!values || values.length < 2) {
+          return true;
+        }
+        const first = values[0]?.cidr || '';
+        const second = values[1]?.cidr || '';
+        if (!first || !second) {
+          return true;
+        }
+        const firstIsCidr = isCIDR.v4(first) || isCIDR.v6(first);
+        const secondIsCidr = isCIDR.v4(second) || isCIDR.v6(second);
+        if (!firstIsCidr || !secondIsCidr) {
+          return true;
+        }
+        return first !== second;
+      },
+    )
+    .test(
+      'dual-stack-opposite-families',
+      `When two ${field} are provided, one must be IPv4 and the other IPv6.`,
+      (values?: { cidr?: MachineNetwork['cidr'] }[]) => {
+        if (!values || values.length < 2) {
+          return true;
+        }
+        const a = values[0]?.cidr || '';
+        const b = values[1]?.cidr || '';
+        if (!a || !b) {
+          return true;
+        }
+        const a4 = isCIDR.v4(a);
+        const a6 = isCIDR.v6(a);
+        const b4 = isCIDR.v4(b);
+        const b6 = isCIDR.v6(b);
+        if (!((a4 || a6) && (b4 || b6))) {
+          return true;
+        }
+        return (a4 && b6) || (a6 && b4);
+      },
     );
 
 export const IPv4ValidationSchema = Yup.array().test(

package/lib/common/components/ui/index.ts

@@ -21,7 +21,7 @@ export { default as PopoverIcon } from './PopoverIcon';
 export { default as WizardNavItem } from './WizardNavItem';
 export { default as Alerts } from './Alerts';
 export { default as ExternalLink } from './ExternalLink';
-export { default as PrismCode, SimpleAIPrismTheme } from './PrismCode';
+export { default as PrismCode } from './PrismCode';
 export { default as GridGap } from './GridGap';
 export { default as EventsList } from './EventsList';
 export { default as ClusterEventsToolbar } from './ClusterEventsToolbar';

package/lib/common/components/ui/uiState/EmptyState.tsx

@@ -1,19 +1,17 @@
 import React from 'react';
 import {
-  Title,
   EmptyState as PFEmptyState,
   EmptyStateBody,
   Bullseye,
-  EmptyStateIcon,
-  EmptyStateIconProps,
   EmptyStateActions,
 } from '@patternfly/react-core';
 import { SearchIcon } from '@patternfly/react-icons/dist/js/icons/search-icon';
+import { ComponentType } from 'react';
 
 type Props = {
   title?: string;
   content?: React.ReactNode;
-  icon?: EmptyStateIconProps['icon'];
+  icon?: ComponentType;
   primaryAction?: React.ReactNode;
   secondaryActions?: React.ReactNode[];
 };
@@ -26,9 +24,7 @@ const EmptyState: React.FC<Props> = ({
   secondaryActions,
 }) => (
   <Bullseye>
-    <PFEmptyState>
-      <EmptyStateIcon icon={icon} />
-      <Title headingLevel="h2">{title}</Title>
+    <PFEmptyState titleText={title} icon={icon} headingLevel="h2">
       {content && <EmptyStateBody>{content}</EmptyStateBody>}
       {primaryAction}
       {secondaryActions && <EmptyStateActions>{secondaryActions}</EmptyStateActions>}

package/lib/common/components/ui/uiState/ErrorState.tsx

@@ -3,24 +3,20 @@ import {
   EmptyState,
   EmptyStateBody,
   Bullseye,
-  EmptyStateIcon,
   EmptyStateVariant,
   Button,
   ButtonVariant,
-  EmptyStateIconProps,
   EmptyStateActions,
-  EmptyStateHeader,
   EmptyStateFooter,
 } from '@patternfly/react-core';
 import { ExclamationCircleIcon } from '@patternfly/react-icons/dist/js/icons/exclamation-circle-icon';
-import { global_danger_color_200 as globalDangerColor200 } from '@patternfly/react-tokens/dist/js/global_danger_color_200';
 import { useTranslation } from '../../../hooks/use-translation-wrapper';
 
 type ErrorStateProps = {
   title?: string;
   content?: React.ReactNode;
   fetchData?: () => void;
-  icon?: EmptyStateIconProps['icon'];
+  icon?: React.ComponentClass;
   iconColor?: string;
   primaryAction?: React.ReactNode;
   actions?: React.ReactNode[];
@@ -49,19 +45,19 @@ const ErrorState = ({
   content,
   fetchData,
   icon = ExclamationCircleIcon,
-  iconColor = globalDangerColor200.value,
   variant = EmptyStateVariant.sm,
   primaryAction,
   actions,
 }: ErrorStateProps) => {
   return (
     <Bullseye>
-      <EmptyState variant={variant}>
-        <EmptyStateHeader
-          titleText={<>{title}</>}
-          icon={<EmptyStateIcon icon={icon} color={iconColor} />}
-          headingLevel="h2"
-        />
+      <EmptyState
+        status="danger"
+        headingLevel="h2"
+        icon={icon}
+        titleText={<>{title}</>}
+        variant={variant}
+      >
         <EmptyStateBody>{content || <DefaultErrorContent fetchData={fetchData} />}</EmptyStateBody>
         <EmptyStateFooter>
           {primaryAction}

package/lib/common/components/ui/uiState/LoadingState.tsx

@@ -17,7 +17,7 @@ type Props = {
 const LoadingState: React.FC<Props> = ({ content, primaryAction, secondaryActions }) => (
   <Bullseye>
     <EmptyState variant={EmptyStateVariant.sm}>
-      <Spinner size="xl" />
+      <Spinner size="xl" data-testid="loading-state-spinner" />
       {content && <EmptyStateBody>{content}</EmptyStateBody>}
       {primaryAction}
       {secondaryActions && <EmptyStateActions>{secondaryActions}</EmptyStateActions>}

package/lib/common/config/constants.ts

@@ -2,6 +2,7 @@ import { TFunction } from 'i18next';
 import { ValidationsInfo, HostRole } from '../types/hosts';
 import {
   Cluster,
+  ClusterDefaultConfig,
   ClusterValidationId,
   DiskRole,
   Event,
@@ -145,6 +146,8 @@ export const hostValidationLabels = (t: TFunction): { [key in HostValidationId]:
   'node-maintenance-requirements-satisfied': t('ai:Node Maintenance requirements'),
   'kube-descheduler-requirements-satisfied': t('ai:Kube Descheduler requirements'),
   'cluster-observability-requirements-satisfied': t('ai:Cluster Observability requirements'),
+  'loki-requirements-satisfied': t('ai:Loki Operator requirements'),
+  'openshift-logging-requirements-satisfied': t('ai:OpenShift Logging Operator requirements'),
   'numa-resources-requirements-satisfied': t('ai:NUMA Resources requirements'),
   'oadp-requirements-satisfied': t('ai:OADP requirements'),
   'metallb-requirements-satisfied': t('ai:MetalLB requirements'),
@@ -216,6 +219,8 @@ export const hostValidationFailureHints = (
   'node-maintenance-requirements-satisfied': '',
   'kube-descheduler-requirements-satisfied': '',
   'cluster-observability-requirements-satisfied': '',
+  'loki-requirements-satisfied': '',
+  'openshift-logging-requirements-satisfied': '',
   'numa-resources-requirements-satisfied': '',
   'oadp-requirements-satisfied': '',
   'metallb-requirements-satisfied': '',
@@ -247,8 +252,11 @@ export const clusterValidationLabels = (
   'lvm-requirements-satisfied': t('ai:Logical Volume Manager requirements'),
   'cnv-requirements-satisfied': t('ai:CNV requirements'),
   'mce-requirements-satisfied': t('ai:MCE requirements'),
+  'openshift-ai-gpu-requirements-satisfied': t('ai:OpenShift AI GPU requirements'),
   'platform-requirements-satisfied': t('ai:Platform requirements'),
   'cluster-observability-requirements-satisfied': t('ai:Cluster Observability requirements'),
+  'loki-requirements-satisfied': t('ai:Loki Operator requirements'),
+  'openshift-logging-requirements-satisfied': t('ai:OpenShift Logging Operator requirements'),
   'numa-resources-requirements-satisfied': t('ai:NUMA Resources requirements'),
   'oadp-requirements-satisfied': t('ai:OADP requirements'),
   'metallb-requirements-satisfied': t('ai:MetalLB requirements'),
@@ -271,9 +279,39 @@ export const CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4 = {
 };
 
 export const CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV6 = {
-  clusterNetworkCidr: '2002:db8::/53',
+  clusterNetworkCidr: 'fd01::/48',
   clusterNetworkHostPrefix: 64,
-  serviceNetworkCidr: '2003:db8::/112',
+  serviceNetworkCidr: 'fd02::/112',
+};
+
+export const CLUSTER_DEFAULT_NETWORK_SETTINGS: Pick<
+  ClusterDefaultConfig,
+  | 'clusterNetworksIpv4'
+  | 'clusterNetworksDualstack'
+  | 'serviceNetworksIpv4'
+  | 'serviceNetworksDualstack'
+> = {
+  clusterNetworksIpv4: [
+    {
+      cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.clusterNetworkCidr,
+      hostPrefix: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.clusterNetworkHostPrefix,
+    },
+  ],
+  clusterNetworksDualstack: [
+    {
+      cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.clusterNetworkCidr,
+      hostPrefix: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.clusterNetworkHostPrefix,
+    },
+    {
+      cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV6.clusterNetworkCidr,
+      hostPrefix: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV6.clusterNetworkHostPrefix,
+    },
+  ],
+  serviceNetworksIpv4: [{ cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.serviceNetworkCidr }],
+  serviceNetworksDualstack: [
+    { cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV4.serviceNetworkCidr },
+    { cidr: CLUSTER_DEFAULT_NETWORK_SETTINGS_IPV6.serviceNetworkCidr },
+  ],
 };
 
 /**
@@ -333,6 +371,8 @@ export const OPERATOR_NAME_FENCE_AGENTS_REMEDIATION = 'fence-agents-remediation'
 export const OPERATOR_NAME_NODE_MAINTENANCE = 'node-maintenance';
 export const OPERATOR_NAME_KUBE_DESCHEDULER = 'kube-descheduler';
 export const OPERATOR_NAME_CLUSTER_OBSERVABILITY = 'cluster-observability';
+export const OPERATOR_NAME_LOKI = 'loki';
+export const OPERATOR_NAME_OPENSHIFT_LOGGING = 'openshift-logging';
 export const OPERATOR_NAME_NUMA_RESOURCES = 'numaresources';
 export const OPERATOR_NAME_OADP = 'oadp';
 export const OPERATOR_NAME_METALLB = 'metallb';
@@ -345,6 +385,9 @@ export const singleClusterOperators = [
   OPERATOR_NAME_NODE_MAINTENANCE,
   OPERATOR_NAME_FENCE_AGENTS_REMEDIATION,
   OPERATOR_NAME_KUBE_DESCHEDULER,
+  OPERATOR_NAME_CLUSTER_OBSERVABILITY,
+  OPERATOR_NAME_LOKI,
+  OPERATOR_NAME_OPENSHIFT_LOGGING,
 ];
 
 export const singleClusterBundles = ['virtualization'];

package/lib/common/config/docs_links.ts

@@ -76,6 +76,8 @@ export const NUTANIX_CONFIG_LINK = `https://docs.redhat.com/en/documentation/ass
 
 export const VSPHERE_CONFIG_LINK = `https://docs.redhat.com/en/documentation/assisted_installer_for_openshift_container_platform/${getYearForAssistedInstallerDocumentationLink()}/html-single/installing_openshift_container_platform_with_the_assisted_installer/index#adding-hosts-on-vsphere_installing-on-vsphere`;
 
+export const VSPHERE_LIMITATIONS_LINK = `https://docs.redhat.com/en/documentation/assisted_installer_for_openshift_container_platform/${getYearForAssistedInstallerDocumentationLink()}/html/installing_openshift_container_platform_with_the_assisted_installer/installing-on-vsphere`;
+
 export const OCI_CONFIG_LINK = `https://docs.redhat.com/en/documentation/assisted_installer_for_openshift_container_platform/${getYearForAssistedInstallerDocumentationLink()}/html-single/installing_openshift_container_platform_with_the_assisted_installer/index#installing-on-oci`;
 
 export const HOW_TO_KNOW_IF_CLUSTER_SUPPORTS_MULTIPLE_CPU_ARCHS = `https://docs.redhat.com/en/documentation/assisted_installer_for_openshift_container_platform/${getYearForAssistedInstallerDocumentationLink()}/html/installing_openshift_container_platform_with_the_assisted_installer/expanding-the-cluster#checking-for-multiple-architectures_expanding-the-cluster`;
@@ -145,8 +147,12 @@ export const FEEDBACK_FORM_LINK =
 export const CHANGE_ISO_PASSWORD_FILE_LINK =
   'https://raw.githubusercontent.com/openshift/assisted-service/master/docs/change-iso-password.sh';
 
-export const getCiscoIntersightLink = (downloadIsoUrl: string) =>
-  `https://www.intersight.com/an/workflow/workflow-definitions/execute/AddServersFromISO?_workflow_Version=1&IsoUrl=${downloadIsoUrl}`;
+export const getCiscoIntersightLink = (downloadIsoUrl: string, ciscoUrl?: string) => {
+  if (ciscoUrl) {
+    return `${ciscoUrl}?_workflow_Version=1&IsoUrl=${downloadIsoUrl}`;
+  }
+  return `https://www.intersight.com/an/workflow/workflow-definitions/execute/AddServersFromISO?_workflow_Version=1&IsoUrl=${downloadIsoUrl}`;
+};
 
 export const MTV_LINK =
   'https://docs.redhat.com/en/documentation/migration_toolkit_for_virtualization/2.7/';
@@ -171,10 +177,12 @@ export const getLsoLink = (ocpVersion?: string) => {
     : `https://docs.openshift.com/container-platform/${version}/storage/persistent_storage/persistent_storage_local/ways-to-provision-local-storage.html`;
 };
 
-export const getNmstateLink = (ocpVersion?: string) =>
-  `https://docs.redhat.com/en/documentation/openshift_container_platform/${getDocsOpenshiftVersion(
-    ocpVersion,
-  )}/html/networking/networking-operators#k8s-nmstate-about-the-k8s-nmstate-operator`;
+export const getNmstateLink = (ocpVersion?: string) => {
+  const version = getDocsOpenshiftVersion(ocpVersion);
+  return isMajorMinorVersionEqualOrGreater(ocpVersion, '4.17')
+    ? `https://docs.redhat.com/en/documentation/openshift_container_platform/${version}/html/networking_operators/k8s-nmstate-about-the-k8s-nmstate-operator`
+    : `https://docs.redhat.com/en/documentation/openshift_container_platform/4.17/html/networking_operators/k8s-nmstate-about-the-k8s-nmstate-operator`;
+};
 
 export const getNodeFeatureDiscoveryLink = (ocpVersion?: string) =>
   `https://docs.redhat.com/en/documentation/openshift_container_platform/${getDocsOpenshiftVersion(
@@ -215,6 +223,16 @@ export const getClusterObservabilityLink = (ocpVersion?: string) =>
     ocpVersion,
   )}/html/cluster_observability_operator/cluster-observability-operator-overview`;
 
+export const getLokiLink = (ocpVersion?: string) =>
+  `https://docs.redhat.com/en/documentation/openshift_container_platform/${getDocsOpenshiftVersion(
+    ocpVersion,
+  )}/html/network_observability/network-observability-overview`;
+
+export const getOpenShiftLoggingLink = (ocpVersion?: string) =>
+  `https://docs.redhat.com/en/documentation/openshift_container_platform/${getDocsOpenshiftVersion(
+    ocpVersion,
+  )}/html/logging`;
+
 export const getNumaResourcesLink = (ocpVersion?: string) =>
   `https://docs.redhat.com/en/documentation/openshift_container_platform/${getDocsOpenshiftVersion(
     ocpVersion,

package/lib/common/reducers/alertsSlice.ts

@@ -6,6 +6,7 @@ export type AlertPayload = {
   title: string;
   message?: string;
   variant?: AlertVariant;
+  key?: string;
 };
 
 export type AlertProps = {
@@ -22,7 +23,7 @@ export const alertsSlice = createSlice({
   name: 'alerts',
   reducers: {
     addAlert: (state, action: PayloadAction<AlertPayload>) => [
-      { key: uuidv4(), variant: AlertVariant.danger, ...action.payload },
+      { key: action.payload.key || uuidv4(), variant: AlertVariant.danger, ...action.payload },
       ...state,
     ],
     removeAlert: (state, action: PayloadAction<string>) =>

package/lib/common/types/clusters.ts

@@ -45,7 +45,6 @@ export type NetworkConfigurationValues = Pick<
   | 'clusterNetworks'
   | 'serviceNetworks'
 > & {
-  hostSubnet?: string;
   managedNetworkingType: 'userManaged' | 'clusterManaged';
   stackType?: 'singleStack' | 'dualStack';
   apiVip?: string;