@openshift-assisted/ui-lib 2.8.3-cim → 2.9.5-cim

package/lib/ocm/components/clusters/clusterPolling.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { useSelector, useDispatch } from 'react-redux';
-import { Cluster, ResourceUIState, POLLING_INTERVAL } from '../../../common';
+import { ResourceUIState, POLLING_INTERVAL } from '../../../common';
 import {
   fetchClusterAsync,
   cleanCluster,
@@ -10,6 +10,7 @@ import {
   ClusterDispatch,
 } from '../../reducers/clusters';
 import { selectCurrentClusterState } from '../../selectors';
+import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
 
 const shouldRefetch = (uiState: ResourceUIState, hasClusterData: boolean) => {
   if (uiState === ResourceUIState.POLLING_ERROR) {

package/lib/ocm/components/clusters/utils.ts

@@ -1,11 +1,11 @@
 import {
   Cluster,
-  selectOlmOperators,
   LogsState,
   MonitoredOperator,
   MonitoredOperatorsList,
   OperatorCreateParams,
-} from '../../../common';
+} from '@openshift-assisted/types/assisted-installer-service';
+import { selectOlmOperators } from '../../../common';
 
 // The Day2 cluster
 export const isAddHostsCluster = (cluster: Cluster) => cluster.kind === 'AddHostsCluster';

package/lib/ocm/components/featureSupportLevels/FeatureSupportLevelProvider.tsx

@@ -1,93 +1,45 @@
-import useSWR from 'swr';
 import React, { PropsWithChildren } from 'react';
-import * as Sentry from '@sentry/browser';
 import {
   ActiveFeatureConfiguration,
-  Cluster,
   CpuArchitecture,
   FeatureId,
-  FeatureIdToSupportLevel,
-  FeatureSupportLevelContextProvider,
-  FeatureSupportLevelData,
-  FeatureSupportLevels,
-  FeatureSupportLevelsMap,
   getDefaultCpuArchitecture,
-  SupportLevel,
 } from '../../../common';
-import { handleApiError } from '../../api';
-import { FeatureSupportLevelsAPI } from '../../services/apis';
-import { captureException } from '../../sentry';
 import { useOpenshiftVersions, usePullSecret } from '../../hooks';
-import { getFeatureDisabledReason, isFeatureSupported } from './featureStateUtils';
+import { getNewFeatureDisabledReason, isFeatureSupportedAndAvailable } from './featureStateUtils';
 import useInfraEnv from '../../hooks/useInfraEnv';
-import { isFeatureSupportedAndAvailable } from '../newFeatureSupportLevels/newFeatureStateUtils';
+import {
+  NewFeatureSupportLevelContextProvider,
+  NewFeatureSupportLevelData,
+  NewFeatureSupportLevelMap,
+} from '../../../common/components/newFeatureSupportLevels';
+import useSupportLevelsAPI from '../../hooks/useSupportLevelsAPI';
+import {
+  Cluster,
+  SupportLevel,
+  SupportLevels,
+} from '@openshift-assisted/types/assisted-installer-service';
 
-export type SupportLevelProviderProps = PropsWithChildren<{
+export type NewSupportLevelProviderProps = PropsWithChildren<{
   clusterFeatureUsage?: string;
   openshiftVersion?: string;
   loadingUi: React.ReactNode;
   cluster?: Cluster;
+  cpuArchitecture?: string;
 }>;
 
-const getFeatureSupportLevelsMap = (
-  featureSupportLevels: FeatureSupportLevels,
-): FeatureSupportLevelsMap => {
-  try {
-    const featureSupportLevelsMap: FeatureSupportLevelsMap = {};
-    for (const { openshiftVersion, features } of featureSupportLevels) {
-      if (!openshiftVersion || !features) {
-        continue;
-      }
-      featureSupportLevelsMap[openshiftVersion] = {};
-      for (const { featureId, supportLevel } of features) {
-        if (!featureId || !supportLevel) {
-          continue;
-        }
-        featureSupportLevelsMap[openshiftVersion][featureId] = supportLevel;
-      }
-    }
-    return featureSupportLevelsMap;
-  } catch (err) {
-    captureException(err, 'Failed to parse feature support levels', Sentry.Severity.Warning);
-    return {};
-  }
-};
-
-const getVersionSupportLevelsMap = (
-  versionName: string,
-  supportLevelData: FeatureSupportLevelsMap,
-): FeatureIdToSupportLevel | undefined => {
-  // There is only one feature-support-level item per minor OpenShift version
-  // To solve the problem of partial matching (4.1 vs 4.11), we sort the list from most recent to least recent.
-  const versionKey = Object.keys(supportLevelData)
-    .reverse()
-    .find((key) => versionName.startsWith(key));
-  if (!versionKey) {
-    return undefined;
-  }
-
-  return supportLevelData[versionKey];
+export const getFeatureSupported = (featureSupportLevels: SupportLevels, featureId: FeatureId) => {
+  return featureSupportLevels && isFeatureSupportedAndAvailable(featureSupportLevels[featureId]);
 };
 
-export const getFeatureSupported = (
-  openshiftVersion: string,
-  featureSupportLevels: FeatureSupportLevels,
-  featureId: FeatureId,
-) => {
-  const featureSupportLevelsMap = getFeatureSupportLevelsMap(featureSupportLevels);
-  const versionSupportLevels = getVersionSupportLevelsMap(
-    openshiftVersion,
-    featureSupportLevelsMap,
-  );
-  return versionSupportLevels && isFeatureSupportedAndAvailable(versionSupportLevels[featureId]);
-};
-
-export const FeatureSupportLevelProvider: React.FC<SupportLevelProviderProps> = ({
+export const NewFeatureSupportLevelProvider: React.FC<NewSupportLevelProviderProps> = ({
   cluster,
   children,
   loadingUi,
+  cpuArchitecture,
+  openshiftVersion,
 }) => {
-  const { loading: loadingOCPVersions, versions: versionOptions } = useOpenshiftVersions();
+  const { loading: loadingOCPVersions } = useOpenshiftVersions();
   const pullSecret = usePullSecret();
   const { infraEnv, isLoading: isInfraEnvLoading } = useInfraEnv(
     cluster?.id || '',
@@ -98,20 +50,16 @@ export const FeatureSupportLevelProvider: React.FC<SupportLevelProviderProps> =
     pullSecret,
     cluster?.openshiftVersion,
   );
-  const fetcher = () => FeatureSupportLevelsAPI.list().then((res) => res.data);
-  const { data: featureSupportLevels, error } = useSWR<FeatureSupportLevels, unknown>(
-    FeatureSupportLevelsAPI.makeBaseURI(),
-    fetcher,
-    { errorRetryCount: 0, revalidateOnFocus: false },
-  );
-  const isLoading = (!featureSupportLevels && !error) || loadingOCPVersions || isInfraEnvLoading;
+  const featureSupportLevels = useSupportLevelsAPI('features', openshiftVersion, cpuArchitecture);
 
-  const supportLevelData = React.useMemo<FeatureSupportLevelsMap>(() => {
-    if (!featureSupportLevels || error) {
-      return {};
+  const supportLevelData = React.useMemo<NewFeatureSupportLevelMap>(() => {
+    if (!featureSupportLevels) {
+      return {} as NewFeatureSupportLevelMap;
     }
-    return getFeatureSupportLevelsMap(featureSupportLevels);
-  }, [error, featureSupportLevels]);
+    return featureSupportLevels;
+  }, [featureSupportLevels]);
+
+  const isLoading = !supportLevelData || loadingOCPVersions || isInfraEnvLoading;
 
   const activeFeatureConfiguration = React.useMemo<ActiveFeatureConfiguration>(
     () => ({
@@ -123,54 +71,66 @@ export const FeatureSupportLevelProvider: React.FC<SupportLevelProviderProps> =
     [cluster?.cpuArchitecture, infraEnv?.cpuArchitecture, infraEnv?.staticNetworkConfig],
   );
 
-  const getVersionSupportLevelsMapCallback = React.useCallback(
-    (versionName: string): FeatureIdToSupportLevel | undefined => {
-      return getVersionSupportLevelsMap(versionName, supportLevelData);
-    },
-    [supportLevelData],
-  );
+  const getFeatureSupportLevels = React.useCallback((): NewFeatureSupportLevelMap => {
+    return supportLevelData;
+  }, [supportLevelData]);
 
   const getFeatureSupportLevel = React.useCallback(
-    (versionName: string, featureId: FeatureId): SupportLevel | undefined => {
-      const versionSupportLevelData = getVersionSupportLevelsMapCallback(versionName);
-      return versionSupportLevelData ? versionSupportLevelData[featureId] : undefined;
+    (
+      featureId: FeatureId,
+      supportLevelDataNew?: NewFeatureSupportLevelMap,
+    ): SupportLevel | undefined => {
       // eslint-disable-next-line react-hooks/exhaustive-deps
+      if (supportLevelDataNew) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return supportLevelDataNew ? (supportLevelDataNew[featureId] as SupportLevel) : undefined;
+      } else {
+        if (supportLevelData) {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          return supportLevelData ? (supportLevelData[featureId] as SupportLevel) : undefined;
+        }
+      }
     },
-    [getVersionSupportLevelsMapCallback],
+    [supportLevelData],
   );
 
   const isFeatureSupportedCallback = React.useCallback(
-    (versionName: string, featureId: FeatureId) => {
-      const supportLevel = getFeatureSupportLevel(versionName, featureId);
-      return isFeatureSupported(versionName, featureId, supportLevel, versionOptions);
+    (featureId: FeatureId, supportLevelDataNew?: NewFeatureSupportLevelMap) => {
+      const supportLevel = getFeatureSupportLevel(featureId, supportLevelDataNew);
+      return isFeatureSupportedAndAvailable(supportLevel);
     },
-    [getFeatureSupportLevel, versionOptions],
+    [getFeatureSupportLevel],
   );
 
-  //TODO(brotman): move to separate context FeatureStateContext
   const getDisabledReasonCallback = React.useCallback(
-    (versionName: string, featureId: FeatureId) => {
-      const isSupported = isFeatureSupportedCallback(versionName, featureId);
-      return getFeatureDisabledReason(
+    (
+      featureId: FeatureId,
+      supportLevelDataNew?: NewFeatureSupportLevelMap,
+      cpuArchitecture?: string,
+    ) => {
+      const isSupported = isFeatureSupportedCallback(featureId, supportLevelDataNew);
+      return getNewFeatureDisabledReason(
         featureId,
         cluster,
         activeFeatureConfiguration,
-        versionName,
-        versionOptions,
         isSupported,
+        cpuArchitecture,
       );
     },
-    [isFeatureSupportedCallback, versionOptions, cluster, activeFeatureConfiguration],
+    [isFeatureSupportedCallback, cluster, activeFeatureConfiguration],
   );
 
   const isFeatureDisabled = React.useCallback(
-    (version: string, featureId: FeatureId) => !!getDisabledReasonCallback(version, featureId),
+    (featureId: FeatureId, supportLevelDataNew?: NewFeatureSupportLevelMap) =>
+      !!getDisabledReasonCallback(featureId, supportLevelDataNew),
     [getDisabledReasonCallback],
   );
 
-  const providerValue = React.useMemo<FeatureSupportLevelData>(() => {
+  const providerValue = React.useMemo<NewFeatureSupportLevelData>(() => {
     return {
-      getVersionSupportLevelsMap: getVersionSupportLevelsMapCallback,
+      getFeatureSupportLevels: getFeatureSupportLevels,
       getFeatureSupportLevel: getFeatureSupportLevel,
       isFeatureDisabled: isFeatureDisabled,
       getFeatureDisabledReason: getDisabledReasonCallback,
@@ -178,7 +138,7 @@ export const FeatureSupportLevelProvider: React.FC<SupportLevelProviderProps> =
       activeFeatureConfiguration,
     };
   }, [
-    getVersionSupportLevelsMapCallback,
+    getFeatureSupportLevels,
     getFeatureSupportLevel,
     isFeatureDisabled,
     getDisabledReasonCallback,
@@ -186,17 +146,11 @@ export const FeatureSupportLevelProvider: React.FC<SupportLevelProviderProps> =
     activeFeatureConfiguration,
   ]);
 
-  React.useEffect(() => {
-    if (error) {
-      handleApiError(error);
-    }
-  }, [error]);
-
   return (
-    <FeatureSupportLevelContextProvider value={providerValue}>
+    <NewFeatureSupportLevelContextProvider value={providerValue}>
       {isLoading ? loadingUi : children}
-    </FeatureSupportLevelContextProvider>
+    </NewFeatureSupportLevelContextProvider>
   );
 };
 
-export default FeatureSupportLevelProvider;
+export default NewFeatureSupportLevelProvider;

package/lib/ocm/components/featureSupportLevels/ReviewClusterFeatureSupportLevels.tsx

@@ -10,7 +10,7 @@ import {
 } from '../../../common/types';
 import { TECH_SUPPORT_LEVEL_LINK } from '../../../common/config/constants';
 import ExternalLink from '../../../common/components/ui/ExternalLink';
-import { Cluster } from '../../../common/api/types';
+import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
 import { DetailItem } from '../../../common';
 import { getLimitedFeatureSupportLevels } from '../../../common/components/newFeatureSupportLevels/utils';
 import { WithErrorBoundary } from '../../../common/components/ErrorHandling/WithErrorBoundary';
@@ -179,13 +179,7 @@ const SupportLevel = ({ cluster }: SupportLevelProps) => {
 };
 
 const ClusterFeatureSupportLevelsDetailItem = ({ ...props }: SupportLevelProps) => (
-  <WithErrorBoundary
-    title="Feature support levels not available"
-    content={`OpenShift version ${
-      props.cluster.openshiftVersion || ''
-    } does not currently review feature support levels.`}
-    showReloadAction={false}
-  >
+  <WithErrorBoundary title="Failed to load feature support levels">
     <SupportLevel {...props} />
   </WithErrorBoundary>
 );

package/lib/ocm/components/featureSupportLevels/featureStateUtils.ts

@@ -1,24 +1,19 @@
 import {
   ActiveFeatureConfiguration,
-  Cluster,
   CpuArchitecture,
   FeatureId,
   isSNO,
-  OpenshiftVersionOptionType,
   OperatorsValues,
-  SupportLevel,
+  SupportedCpuArchitecture,
 } from '../../../common';
-import { isFeatureSupportedAndAvailable } from '../newFeatureSupportLevels/newFeatureStateUtils';
+import { architectureData } from '../clusterConfiguration/CpuArchitectureDropdown';
+import { Cluster, SupportLevel } from '@openshift-assisted/types/assisted-installer-service';
 
 const CNV_OPERATOR_LABEL = 'Openshift Virtualization';
 const LVMS_OPERATOR_LABEL = 'Logical Volume Manager Storage';
 const LVM_OPERATOR_LABEL = 'Logical Volume Manager';
 const ODF_OPERATOR_LABEL = 'OpenShift Data Foundation';
 
-const isArmSupported = (versionName: string, versionOptions: OpenshiftVersionOptionType[]) => {
-  const versionOption = versionOptions.find((option) => option.value === versionName);
-  return !!versionOption?.cpuArchitectures?.includes(CpuArchitecture.ARM);
-};
 export const clusterExistsReason = 'This option is not editable after the draft cluster is created';
 
 export const getCnvIncompatibleWithLvmReason = (
@@ -62,18 +57,10 @@ const getSNODisabledReason = (cluster: Cluster | undefined, isSupported: boolean
   return '';
 };
 
-const getArmDisabledReason = (
-  cluster: Cluster | undefined,
-  versionName: string,
-  versionOptions: OpenshiftVersionOptionType[],
-) => {
+const getArmDisabledReason = (cluster: Cluster | undefined) => {
   if (cluster) {
     return clusterExistsReason;
-  }
-  if (!isArmSupported(versionName, versionOptions)) {
-    return 'arm64 is not supported in this OpenShift version';
-  }
-  return undefined;
+  } else return 'arm64 is not supported in this OpenShift version';
 };
 
 const getOdfDisabledReason = (
@@ -101,14 +88,26 @@ const getOdfDisabledReason = (
   return undefined;
 };
 
-const getCnvDisabledReason = (activeFeatureConfiguration: ActiveFeatureConfiguration) => {
+const getCnvDisabledReason = (
+  activeFeatureConfiguration: ActiveFeatureConfiguration,
+  isSupported: boolean,
+) => {
   if (!activeFeatureConfiguration) {
     return undefined;
   }
-  if (activeFeatureConfiguration.underlyingCpuArchitecture === CpuArchitecture.ARM) {
-    return `${CNV_OPERATOR_LABEL} is not available when ARM CPU architecture is selected.`;
+  if (!isSupported) {
+    const cpuArchitectureLabel =
+      architectureData[
+        activeFeatureConfiguration.underlyingCpuArchitecture as SupportedCpuArchitecture
+      ].label;
+    return `${CNV_OPERATOR_LABEL} is not available when ${
+      cpuArchitectureLabel
+        ? cpuArchitectureLabel
+        : activeFeatureConfiguration.underlyingCpuArchitecture
+    } CPU architecture is selected.`;
+  } else {
+    return undefined;
   }
-  return undefined;
 };
 
 const getLvmDisabledReason = (
@@ -135,23 +134,22 @@ const getNetworkTypeSelectionDisabledReason = (cluster: Cluster | undefined) =>
   return undefined;
 };
 
-export const getFeatureDisabledReason = (
+export const getNewFeatureDisabledReason = (
   featureId: FeatureId,
   cluster: Cluster | undefined,
   activeFeatureConfiguration: ActiveFeatureConfiguration,
-  versionName: string,
-  versionOptions: OpenshiftVersionOptionType[],
   isSupported: boolean,
+  cpuArchitecture?: string,
 ): string | undefined => {
   switch (featureId) {
     case 'SNO': {
       return getSNODisabledReason(cluster, isSupported);
     }
     case 'ARM64_ARCHITECTURE': {
-      return getArmDisabledReason(cluster, versionName, versionOptions);
+      return getArmDisabledReason(cluster);
     }
     case 'CNV': {
-      return getCnvDisabledReason(activeFeatureConfiguration);
+      return getCnvDisabledReason(activeFeatureConfiguration, isSupported);
     }
     case 'LVM': {
       return getLvmDisabledReason(activeFeatureConfiguration, isSupported);
@@ -162,8 +160,22 @@ export const getFeatureDisabledReason = (
     case 'NETWORK_TYPE_SELECTION': {
       return getNetworkTypeSelectionDisabledReason(cluster);
     }
-    case 'ARM64_ARCHITECTURE_WITH_CLUSTER_MANAGED_NETWORKING': {
-      return 'Network management selection is not supported for ARM architecture with this version of OpenShift.';
+    case 'CLUSTER_MANAGED_NETWORKING': {
+      return 'Cluster-managed networking is not supported for ARM architecture with this version of OpenShift.';
+    }
+    case 'EXTERNAL_PLATFORM_OCI': {
+      if (cpuArchitecture === 's390x') {
+        return "Can't set Oracle platform on s390x architecture";
+      } else {
+        return 'Integration with Oracle is available for OpenShift 4.14 and later versions.';
+      }
+    }
+    case 'MCE': {
+      if (!isSupported) {
+        return 'Multicluster engine is not supported in this OpenShift version.';
+      } else {
+        return undefined;
+      }
     }
     default: {
       return undefined;
@@ -171,15 +183,9 @@ export const getFeatureDisabledReason = (
   }
 };
 
-export const isFeatureSupported = (
-  versionName: string,
-  featureId: FeatureId,
-  supportLevel: SupportLevel | undefined,
-  versionOptions: OpenshiftVersionOptionType[],
-) => {
-  if (featureId === 'ARM64_ARCHITECTURE') {
-    return isArmSupported(versionName, versionOptions);
-  } else {
-    return isFeatureSupportedAndAvailable(supportLevel);
-  }
+export const isFeatureSupportedAndAvailable = (supportLevel: SupportLevel | undefined): boolean => {
+  return supportLevel !== 'unsupported' && supportLevel !== 'unavailable';
 };
+
+export const hostsNetworkConfigurationDisabledReason =
+  "DHCP only is the supported hosts' network configuration when external partner integrations is selected";

package/lib/ocm/components/featureSupportLevels/index.ts

@@ -1,2 +1,3 @@
-export { default as FeatureSupportLevelProvider } from './FeatureSupportLevelProvider';
+export { default as NewFeatureSupportLevelProvider } from './FeatureSupportLevelProvider';
 export { default as ClusterFeatureSupportLevelsDetailItem } from './ReviewClusterFeatureSupportLevels';
+export * from '../../../common/components/featureSupportLevels/types';

package/lib/ocm/components/fetching/fetchEvents.ts

@@ -1,9 +1,9 @@
 import { AxiosError, AxiosResponseHeaders } from 'axios';
-import { EVENT_SEVERITIES, Event, EventListFetchProps } from '../../../common';
+import { EVENT_SEVERITIES, EventListFetchProps } from '../../../common';
 import { handleApiError } from '../../api';
 import { EventsAPI } from '../../services/apis';
 import { SeverityCountsType } from '../../../common/components/ui/ClusterEventsToolbar';
-
+import { Event } from '@openshift-assisted/types/assisted-installer-service';
 const parseHeaders = (headers: AxiosResponseHeaders) => {
   const severities: Record<Event['severity'], number> = {
     error: 0,
@@ -21,11 +21,9 @@ const parseHeaders = (headers: AxiosResponseHeaders) => {
   };
 };
 
-export const onFetchEvents: EventListFetchProps['onFetchEvents'] = async (
-  props,
-  onSuccess,
-  onError,
-) => {
+const fetchEventsAsync = async (...args: Parameters<typeof onFetchEvents>): Promise<void> => {
+  const [props, onSuccess, onError] = args;
+
   try {
     EventsAPI.abort();
     const response = await EventsAPI.list(props);
@@ -42,3 +40,7 @@ export const onFetchEvents: EventListFetchProps['onFetchEvents'] = async (
     }
   }
 };
+
+export const onFetchEvents: EventListFetchProps['onFetchEvents'] = (props, onSuccess, onError) => {
+  void fetchEventsAsync(props, onSuccess, onError);
+};

package/lib/ocm/components/hosts/ClusterHostsTable.tsx

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { Cluster, selectSchedulableMasters, Host, isSNO } from '../../../common';
+import { selectSchedulableMasters, isSNO } from '../../../common';
 import { AdditionalNTPSourcesDialogToggle } from './AdditionaNTPSourceDialogToggle';
 import {
   discoveredAtColumn,
@@ -23,6 +23,8 @@ import {
   useHostsTableDetailContext,
 } from '../../../common/components/hosts/HostsTableDetailContext';
 import { TableVariant } from '@patternfly/react-table';
+import { ClusterWizardContext } from '../clusterWizard/ClusterWizardContext';
+import { Cluster, Host } from '@openshift-assisted/types/assisted-installer-service';
 
 export function ExpandComponent({ obj: host }: ExpandComponentProps<Host>) {
   const { onDiskRole, canEditDisks, updateDiskSkipFormatting } = useHostsTableDetailContext();
@@ -44,6 +46,7 @@ export interface ClusterHostsTableProps {
 }
 
 const ClusterHostsTable = ({ cluster, skipDisabled }: ClusterHostsTableProps) => {
+  const { wizardPerPage, setWizardPerPage } = React.useContext(ClusterWizardContext) || {};
   const {
     onEditHost,
     onEditRole,
@@ -71,16 +74,16 @@ const ClusterHostsTable = ({ cluster, skipDisabled }: ClusterHostsTableProps) =>
         onEditHost,
         UpdateDay2ApiVipDialogToggle,
       ),
-      discoveredAtColumn,
-      cpuCoresColumn,
-      memoryColumn,
-      disksColumn,
+      discoveredAtColumn(t),
+      cpuCoresColumn(t),
+      memoryColumn(t),
+      disksColumn(t),
     ],
     [t, onEditHost, actionChecks, onEditRole, cluster],
   );
 
   const hosts = cluster.hosts || [];
-  const paginationProps = usePagination(hosts.length);
+  const paginationProps = usePagination(hosts.length, wizardPerPage, setWizardPerPage);
 
   return (
     <>

package/lib/ocm/components/hosts/DeleteHostModal.tsx

@@ -10,7 +10,7 @@ type DeleteHostModalProps = {
 
 const DeleteHostModal = ({ isOpen, hostname, onClose, onDelete }: DeleteHostModalProps) => (
   <Modal
-    title="Delete Host"
+    title="Remove host?"
     isOpen={isOpen}
     onClose={onClose}
     variant={ModalVariant.small}
@@ -21,14 +21,14 @@ const DeleteHostModal = ({ isOpen, hostname, onClose, onDelete }: DeleteHostModa
         variant={ButtonVariant.danger}
         onClick={onDelete}
       >
-        Delete
+        Remove host
       </Button>,
       <Button key="cancel" variant={ButtonVariant.link} onClick={onClose}>
         Cancel
       </Button>,
     ]}
   >
-    Are you sure you want to delete host{` ${hostname || ''}`} ?
+    Host {hostname || ''} will be removed.
   </Modal>
 );
 

package/lib/ocm/components/hosts/HardwareStatus.tsx

@@ -4,16 +4,16 @@ import {
   areOnlySoftValidationsOfWizardStepFailing,
   getWizardStepHostStatus,
   getWizardStepHostValidationsInfo,
-  Host,
   HostsTableActions,
   hostStatus,
   HostStatus,
-  stringToJSON,
 } from '../../../common';
 import { TableRow } from '../../../common/components/hosts/AITable';
 import { ValidationsInfo } from '../../../common/types/hosts';
 import { wizardStepsValidationsMap } from '../clusterWizard/wizardTransition';
 import { AdditionalNTPSourcesDialogToggle } from './AdditionaNTPSourceDialogToggle';
+import { stringToJSON } from '../../../common/utils';
+import { Host } from '@openshift-assisted/types/assisted-installer-service';
 
 type HardwareStatusProps = {
   host: Host;

package/lib/ocm/components/hosts/HostRequirementsContent.tsx

@@ -1,7 +1,9 @@
 import React from 'react';
 import { List, ListItem, Text, TextContent } from '@patternfly/react-core';
-import { Cluster, ErrorState, ExternalLink, LoadingState, fileSize } from '../../../common';
+import { ErrorState, ExternalLink, LoadingState } from '../../../common';
 import { useClusterPreflightRequirements } from '../../hooks';
+import { fileSize } from '../../../common/utils';
+import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
 
 const DISK_WRITE_SPEED_LINK = 'https://access.redhat.com/solutions/4885641';
 

package/lib/ocm/components/hosts/HostsDiscoveryTable.tsx

@@ -3,8 +3,6 @@ import { Stack, StackItem } from '@patternfly/react-core';
 import {
   ChangeHostnameAction,
   selectSchedulableMasters,
-  Cluster,
-  Host,
   isSNO,
   DeleteHostAction,
   TableToolbar,
@@ -29,6 +27,8 @@ import { hardwareStatusColumn } from './HardwareStatus';
 import HostsTableEmptyState from '../hosts/HostsTableEmptyState';
 import { useSelector } from 'react-redux';
 import { selectCurrentClusterPermissionsState } from '../../selectors';
+import { useClusterWizardContext } from '../clusterWizard/ClusterWizardContext';
+import { Cluster, Host } from '@openshift-assisted/types/assisted-installer-service';
 
 const HostRowDetailExpand = ({ obj: host }: ExpandComponentProps<Host>) => (
   <HostDetail
@@ -55,6 +55,7 @@ const HostsDiscoveryTable = ({ cluster }: HostsDiscoveryTableProps) => {
     onMassDeleteHost,
     ...modalProps
   } = useHostsTable(cluster);
+  const { wizardPerPage, setWizardPerPage } = useClusterWizardContext();
 
   const { isViewerMode } = useSelector(selectCurrentClusterPermissionsState);
   const isSNOCluster = isSNO(cluster);
@@ -70,17 +71,17 @@ const HostsDiscoveryTable = ({ cluster }: HostsDiscoveryTableProps) => {
         cluster.kind,
       ),
       hardwareStatusColumn({ onEditHostname: onEditHost }),
-      discoveredAtColumn,
-      cpuCoresColumn,
-      memoryColumn,
-      disksColumn,
+      discoveredAtColumn(t),
+      cpuCoresColumn(t),
+      memoryColumn(t),
+      disksColumn(t),
       countColumn(cluster),
     ],
     [t, onEditHost, actionChecks.canEditHostname, actionChecks.canEditRole, onEditRole, cluster],
   );
 
   const hosts = cluster.hosts || [];
-  const paginationProps = usePagination(hosts.length);
+  const paginationProps = usePagination(hosts.length, wizardPerPage, setWizardPerPage);
   const itemIDs = hosts.map((h) => h.id);
   const showBulkActions = !(isViewerMode || isSNOCluster);