@openshift-assisted/ui-lib 2.8.2-cim → 2.9.0-cim

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

@@ -11,6 +11,7 @@ import {
   getVipValidationsById,
   DUAL_STACK,
   SupportLevel,
+  PopoverIcon,
 } from '../../../../common';
 import { selectCurrentClusterPermissionsState } from '../../../selectors';
 import { OcmCheckboxField, OcmInputField } from '../../ui/OcmFormFields';
@@ -59,20 +60,6 @@ const VipStaticValue = ({
   return <i>This IP will be allocated by the DHCP server</i>;
 };
 
-const getVipHelperSuffix = (
-  vip?: string,
-  vipDhcpAllocation?: boolean,
-  vipDhcpAllocationFormValue?: boolean,
-): string => {
-  if (!vipDhcpAllocationFormValue) {
-    return 'Make sure that the VIP is unique and not used by any other device on your network.';
-  }
-  if (vipDhcpAllocation && vip) {
-    return 'This IP was allocated by the DHCP server.';
-  }
-  return '';
-};
-
 export type VirtualIPControlGroupProps = {
   cluster: Cluster;
   isVipDhcpAllocationDisabled?: boolean;
@@ -88,16 +75,9 @@ export const VirtualIPControlGroup = ({
   const { isViewerMode } = useSelector(selectCurrentClusterPermissionsState);
   const { t } = useTranslation();
 
-  const apiVipHelperText = `Provide an endpoint for users, both human and machine, to interact with and configure the platform. If needed, contact your IT manager for more information. ${getVipHelperSuffix(
-    cluster.apiVip,
-    cluster.vipDhcpAllocation,
-    values.vipDhcpAllocation,
-  )}`;
-  const ingressVipHelperText = `Provide an endpoint for application traffic flowing in from outside the cluster. If needed, contact your IT manager for more information. ${getVipHelperSuffix(
-    cluster.ingressVip,
-    cluster.vipDhcpAllocation,
-    values.vipDhcpAllocation,
-  )}`;
+  const ipHelperText = 'Make sure the IP is not used by any other device on your network.';
+  const ipPopoverContent =
+    'Provides an endpoint for users, both human and machine, to interact with and configure the platform.';
 
   const {
     'api-vip-defined': apiVipFailedValidationMessage,
@@ -150,9 +130,13 @@ export const VirtualIPControlGroup = ({
       {values.vipDhcpAllocation ? (
         <>
           <FormikStaticField
-            label={`API IP${ipFieldsSuffix}`}
+            label={
+              <>
+                <span>API IP{ipFieldsSuffix}</span> <PopoverIcon bodyContent={ipPopoverContent} />
+              </>
+            }
             name="apiVip"
-            helperText={apiVipHelperText}
+            helperText={ipHelperText}
             value={values.apiVip || ''}
             isValid={!apiVipFailedValidationMessage}
             isRequired
@@ -165,9 +149,14 @@ export const VirtualIPControlGroup = ({
             />
           </FormikStaticField>
           <FormikStaticField
-            label={`Ingress IP${ipFieldsSuffix}`}
+            label={
+              <>
+                <span>Ingress IP{ipFieldsSuffix}</span>{' '}
+                <PopoverIcon bodyContent={ipPopoverContent} />
+              </>
+            }
             name="ingressVip"
-            helperText={ingressVipHelperText}
+            helperText={ipHelperText}
             value={values.ingressVip || ''}
             isValid={!ingressVipFailedValidationMessage}
             isRequired
@@ -183,15 +172,24 @@ export const VirtualIPControlGroup = ({
       ) : (
         <>
           <OcmInputField
-            label={`API IP${ipFieldsSuffix}`}
+            label={
+              <>
+                <span>API IP{ipFieldsSuffix}</span> <PopoverIcon bodyContent={ipPopoverContent} />
+              </>
+            }
             name="apiVip"
-            helperText={apiVipHelperText}
+            helperText={ipHelperText}
             isRequired
           />
           <OcmInputField
             name="ingressVip"
-            label={`Ingress IP${ipFieldsSuffix}`}
-            helperText={ingressVipHelperText}
+            label={
+              <>
+                <span>Ingress IP{ipFieldsSuffix}</span>{' '}
+                <PopoverIcon bodyContent={ipPopoverContent} />
+              </>
+            }
+            helperText={ipHelperText}
             isRequired
           />
         </>

package/lib/ocm/components/clusterConfiguration/platformIntegration/PlatformIntegration.tsx

@@ -20,7 +20,7 @@ const nutanixPlatformMessage =
   'Enable Nutanix platform integration to access features like node auto-scaling directly inside OpenShift.';
 
 const platformIntegrationTooltip =
-  'Platform integration is only applicable on non-SNO deployments and when all discovered hosts originated from the same platform.';
+  'Virtualization platform integration is only applicable on non-SNO deployments and when all discovered hosts originated from the same platform.';
 
 const messages: KeyType = {
   'no-active-integrations': undeterminedPlatformMessage,

package/lib/ocm/components/clusterDetail/AssistedInstallerDetailCard.tsx

@@ -28,6 +28,7 @@ import { SentryErrorMonitorContextProvider } from '../SentryErrorMonitorContextP
 import ClusterWizardContextProvider from '../clusterWizard/ClusterWizardContextProvider';
 import { BackButton } from '../ui/Buttons/BackButton';
 import { NewFeatureSupportLevelProvider } from '../newFeatureSupportLevels';
+import { usePullSecret } from '../../hooks';
 
 type AssistedInstallerDetailCardProps = {
   aiClusterId: string;
@@ -90,12 +91,19 @@ const AssistedInstallerDetailCard = ({
   permissions,
 }: AssistedInstallerDetailCardProps) => {
   const { cluster, uiState } = useClusterPolling(aiClusterId);
+  const pullSecret = usePullSecret();
   const {
     infraEnv,
     isLoading: infraEnvLoading,
     error: infraEnvError,
     updateInfraEnv,
-  } = useInfraEnv(aiClusterId, CpuArchitecture.USE_DAY1_ARCHITECTURE);
+  } = useInfraEnv(
+    aiClusterId,
+    cluster?.cpuArchitecture ? (cluster.cpuArchitecture as CpuArchitecture) : CpuArchitecture.x86,
+    cluster?.name,
+    pullSecret,
+    cluster?.openshiftVersion,
+  );
   if (uiState === ResourceUIState.LOADING || infraEnvLoading) {
     return <LoadingCard />;
   } else if ((uiState === ResourceUIState.POLLING_ERROR && !cluster) || infraEnvError) {
@@ -151,7 +159,9 @@ const AssistedInstallerDetailCard = ({
 
 const Wrapper = (props: AssistedInstallerDetailCardProps) => (
   <Provider store={store}>
-    <AssistedInstallerDetailCard {...props} />
+    <AlertsContextProvider>
+      <AssistedInstallerDetailCard {...props} />
+    </AlertsContextProvider>
   </Provider>
 );
 

package/lib/ocm/components/clusterDetail/AssistedInstallerExtraDetailCard.tsx

@@ -14,6 +14,7 @@ import { selectCurrentClusterState } from '../../selectors';
 import { Grid } from '@patternfly/react-core';
 import { NewFeatureSupportLevelProvider } from '../newFeatureSupportLevels';
 import useInfraEnv from '../../hooks/useInfraEnv';
+import { usePullSecret } from '../../hooks';
 
 type AssistedInstallerExtraDetailCardProps = {
   allEnabledFeatures: FeatureListType;
@@ -23,9 +24,13 @@ const AssistedInstallerExtraDetailCard: React.FC<AssistedInstallerExtraDetailCar
   allEnabledFeatures,
 }) => {
   const { data: cluster } = useSelector(selectCurrentClusterState);
+  const pullSecret = usePullSecret();
   const { infraEnv } = useInfraEnv(
     cluster?.id ? cluster?.id : '',
-    CpuArchitecture.USE_DAY1_ARCHITECTURE,
+    cluster?.cpuArchitecture ? (cluster.cpuArchitecture as CpuArchitecture) : CpuArchitecture.x86,
+    cluster?.name,
+    pullSecret,
+    cluster?.openshiftVersion,
   );
 
   if (!cluster || cluster.status === 'adding-hosts') {
@@ -52,7 +57,9 @@ const AssistedInstallerExtraDetailCard: React.FC<AssistedInstallerExtraDetailCar
 
 const Wrapper: React.FC<AssistedInstallerExtraDetailCardProps> = (props) => (
   <Provider store={store}>
-    <AssistedInstallerExtraDetailCard {...props} />
+    <AlertsContextProvider>
+      <AssistedInstallerExtraDetailCard {...props} />
+    </AlertsContextProvider>
   </Provider>
 );
 

package/lib/ocm/components/clusters/ClusterPage.tsx

@@ -32,14 +32,15 @@ import ClusterPollingErrorModal from '../clusterDetail/ClusterPollingErrorModal'
 import ClusterUpdateErrorModal from '../clusterDetail/ClusterUpdateErrorModal';
 import { BackButton } from '../ui/Buttons/BackButton';
 import { NewFeatureSupportLevelProvider } from '../newFeatureSupportLevels';
+import { usePullSecret } from '../../hooks';
 
 type MatchParams = {
   clusterId: string;
 };
 
-const ClusterPageGeneric: React.FC<{ clusterId: string; showBreadcrumbs: boolean }> = ({
+const ClusterPageGeneric: React.FC<{ clusterId: string; showBreadcrumbs?: boolean }> = ({
   clusterId,
-  showBreadcrumbs,
+  showBreadcrumbs = false,
 }) => {
   if (!clusterId) {
     console.error('ClusterPageGeneric: missing clusterId');
@@ -47,12 +48,19 @@ const ClusterPageGeneric: React.FC<{ clusterId: string; showBreadcrumbs: boolean
   const fetchCluster = useFetchCluster(clusterId);
   const dispatch = useDispatch();
   const { cluster, uiState, errorDetail } = useClusterPolling(clusterId);
+  const pullSecret = usePullSecret();
   const {
     infraEnv,
     isLoading: infraEnvLoading,
     error: infraEnvError,
     updateInfraEnv,
-  } = useInfraEnv(clusterId, CpuArchitecture.USE_DAY1_ARCHITECTURE);
+  } = useInfraEnv(
+    clusterId,
+    cluster?.cpuArchitecture ? (cluster.cpuArchitecture as CpuArchitecture) : CpuArchitecture.x86,
+    cluster?.name,
+    pullSecret,
+    cluster?.openshiftVersion,
+  );
 
   const getContent = (cluster: Cluster, infraEnv: InfraEnv) => {
     if (cluster.status === 'adding-hosts') {
@@ -188,8 +196,12 @@ const ClusterPageGeneric: React.FC<{ clusterId: string; showBreadcrumbs: boolean
 };
 
 export const SingleClusterPage: React.FC<{ clusterId: string }> = ({ clusterId }) => (
-  <ClusterPageGeneric clusterId={clusterId} showBreadcrumbs={false} />
+  <AlertsContextProvider>
+    <ClusterPageGeneric clusterId={clusterId} />
+  </AlertsContextProvider>
 );
 export const ClusterPage: React.FC<RouteComponentProps<MatchParams>> = ({ match }) => (
-  <ClusterPageGeneric clusterId={match.params.clusterId} showBreadcrumbs />
+  <AlertsContextProvider>
+    <ClusterPageGeneric clusterId={match.params.clusterId} showBreadcrumbs />
+  </AlertsContextProvider>
 );

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

@@ -17,7 +17,7 @@ import {
 import { handleApiError } from '../../api';
 import { FeatureSupportLevelsAPI } from '../../services/apis';
 import { captureException } from '../../sentry';
-import { useOpenshiftVersions } from '../../hooks';
+import { useOpenshiftVersions, usePullSecret } from '../../hooks';
 import { getFeatureDisabledReason, isFeatureSupported } from './featureStateUtils';
 import useInfraEnv from '../../hooks/useInfraEnv';
 import { isFeatureSupportedAndAvailable } from '../newFeatureSupportLevels/newFeatureStateUtils';
@@ -88,9 +88,13 @@ export const FeatureSupportLevelProvider: React.FC<SupportLevelProviderProps> =
   loadingUi,
 }) => {
   const { loading: loadingOCPVersions, versions: versionOptions } = useOpenshiftVersions();
+  const pullSecret = usePullSecret();
   const { infraEnv, isLoading: isInfraEnvLoading } = useInfraEnv(
     cluster?.id || '',
-    CpuArchitecture.USE_DAY1_ARCHITECTURE,
+    cluster?.cpuArchitecture ? (cluster.cpuArchitecture as CpuArchitecture) : CpuArchitecture.x86,
+    cluster?.name,
+    pullSecret,
+    cluster?.openshiftVersion,
   );
   const fetcher = () => FeatureSupportLevelsAPI.list().then((res) => res.data);
   const { data: featureSupportLevels, error } = useSWR<FeatureSupportLevels, unknown>(

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

@@ -1,3 +1,4 @@
+import { AxiosError } from 'axios';
 import { EventListFetchProps } from '../../../common';
 import { handleApiError } from '../../api';
 import { EventsAPI } from '../../services/apis';
@@ -8,11 +9,15 @@ export const onFetchEvents: EventListFetchProps['onFetchEvents'] = async (
   onError,
 ) => {
   try {
+    EventsAPI.abort();
     const response = await EventsAPI.list(props);
     onSuccess(response);
   } catch (error) {
-    handleApiError(error, () => {
-      onError('Failed to load events');
-    });
+    const { code } = error as AxiosError;
+    if (!code || code !== 'ERR_CANCELED') {
+      handleApiError(error, () => {
+        onError('Failed to load events');
+      });
+    }
   }
 };

package/lib/ocm/components/newFeatureSupportLevels/NewFeatureSupportLevelProvider.tsx

@@ -8,7 +8,7 @@ import {
   SupportLevel,
   SupportLevels,
 } from '../../../common';
-import { useOpenshiftVersions } from '../../hooks';
+import { useOpenshiftVersions, usePullSecret } from '../../hooks';
 import {
   getNewFeatureDisabledReason,
   isFeatureSupportedAndAvailable,
@@ -42,9 +42,13 @@ export const NewFeatureSupportLevelProvider: React.FC<NewSupportLevelProviderPro
   openshiftVersion,
 }) => {
   const { loading: loadingOCPVersions } = useOpenshiftVersions();
+  const pullSecret = usePullSecret();
   const { infraEnv, isLoading: isInfraEnvLoading } = useInfraEnv(
     cluster?.id || '',
-    CpuArchitecture.USE_DAY1_ARCHITECTURE,
+    cluster?.cpuArchitecture ? (cluster.cpuArchitecture as CpuArchitecture) : CpuArchitecture.x86,
+    cluster?.name,
+    pullSecret,
+    cluster?.openshiftVersion,
   );
   const featureSupportLevels = useSupportLevelsAPI('features', openshiftVersion, cpuArchitecture);
 

package/lib/ocm/hooks/useInfraEnv.ts

@@ -8,6 +8,9 @@ import InfraEnvIdsCacheService from '../services/InfraEnvIdsCacheService';
 export default function useInfraEnv(
   clusterId: Cluster['id'],
   cpuArchitecture: CpuArchitecture,
+  clusterName?: string,
+  pullSecret?: string,
+  openshiftVersion?: string,
 ): {
   infraEnv?: InfraEnv;
   error?: string;
@@ -16,7 +19,13 @@ export default function useInfraEnv(
 } {
   const [infraEnv, setInfraEnv] = React.useState<InfraEnv>();
   const [error, setError] = React.useState('');
-  const { infraEnvId, error: infraEnvIdError } = useInfraEnvId(clusterId, cpuArchitecture);
+  const { infraEnvId, error: infraEnvIdError } = useInfraEnvId(
+    clusterId,
+    cpuArchitecture,
+    clusterName,
+    pullSecret,
+    openshiftVersion,
+  );
 
   const getInfraEnv = React.useCallback(async () => {
     try {

package/lib/ocm/hooks/useInfraEnvId.ts

@@ -1,20 +1,40 @@
 import React from 'react';
-import { Cluster, CpuArchitecture, InfraEnv } from '../../common';
+import { Cluster, ClusterCpuArchitecture, CpuArchitecture, InfraEnv } from '../../common';
 import { getErrorMessage } from '../../common/utils';
 import { InfraEnvsService } from '../services';
 
-export default function useInfraEnvId(clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture) {
+export default function useInfraEnvId(
+  clusterId: Cluster['id'],
+  cpuArchitecture: CpuArchitecture,
+  clusterName?: string,
+  pullSecret?: string,
+  openshiftVersion?: string,
+) {
   const [infraEnvId, setInfraEnv] = React.useState<InfraEnv['id']>();
   const [error, setError] = React.useState('');
 
   const findInfraEnvId = React.useCallback(async () => {
     try {
       const infraEnvId = await InfraEnvsService.getInfraEnvId(clusterId, cpuArchitecture);
-      setInfraEnv(infraEnvId);
+      if (infraEnvId && !(infraEnvId instanceof Error)) {
+        setInfraEnv(infraEnvId);
+      } else {
+        //If infraEnv doesn't exist create a new one
+        if (pullSecret) {
+          const infraEnv = await InfraEnvsService.create({
+            name: InfraEnvsService.makeInfraEnvName(cpuArchitecture, clusterName),
+            pullSecret,
+            clusterId: clusterId,
+            openshiftVersion,
+            cpuArchitecture: cpuArchitecture as ClusterCpuArchitecture,
+          });
+          setInfraEnv(infraEnv.id);
+        }
+      }
     } catch (e) {
       setError(getErrorMessage(e));
     }
-  }, [clusterId, cpuArchitecture]);
+  }, [clusterId, cpuArchitecture, clusterName, pullSecret, openshiftVersion]);
 
   React.useEffect(() => {
     if (!clusterId) {

package/lib/ocm/hooks/useInfraEnvImageUrl.ts

@@ -14,7 +14,7 @@ export default function useInfraEnvImageUrl() {
     async (clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture): Promise<ImgUrl> => {
       try {
         const infraEnvId = await InfraEnvsService.getInfraEnvId(clusterId, cpuArchitecture);
-        if (!infraEnvId) {
+        if (!infraEnvId || infraEnvId instanceof Error) {
           return { url: '', error: `Failed to retrieve the infraEnv for ${clusterId}` };
         }
 

package/lib/ocm/hooks/useInfraEnvIpxeImageUrl.ts

@@ -14,7 +14,7 @@ export default function useInfraEnvIpxeImageUrl() {
     async (clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture): Promise<ImgUrl> => {
       try {
         const infraEnvId = await InfraEnvsService.getInfraEnvId(clusterId, cpuArchitecture);
-        if (!infraEnvId) {
+        if (!infraEnvId || infraEnvId instanceof Error) {
           return { url: '', error: `Failed to retrieve the infraEnv for ${clusterId}` };
         }
 

package/lib/ocm/services/Day2ClusterService.ts

@@ -1,18 +1,8 @@
 import { InfraEnvsService } from '.';
 import { ClustersAPI } from './apis';
-import {
-  Cluster,
-  ClusterCpuArchitecture,
-  CpuArchitecture,
-  getSupportedCpuArchitectures,
-  OcmCpuArchitecture,
-  SupportedCpuArchitecture,
-} from '../../common';
+import { Cluster, ClusterCpuArchitecture, CpuArchitecture } from '../../common';
 import { OcmClusterType } from '../components/AddHosts/types';
-import {
-  mapOcmArchToCpuArchitecture,
-  mapClusterCpuArchToInfraEnvCpuArch,
-} from './CpuArchitectureService';
+import { mapOcmArchToCpuArchitecture } from './CpuArchitectureService';
 
 export const getApiVipDnsName = (ocmCluster: OcmClusterType) => {
   let apiVipDnsname = '';
@@ -44,13 +34,7 @@ const Day2ClusterService = {
     return ocmCluster && ocmCluster.external_id;
   },
 
-  async fetchCluster(
-    ocmCluster: OcmClusterType,
-    pullSecret: string,
-    openshiftVersion: string,
-    cpuArchitecturesByVersionImage: CpuArchitecture[],
-    canSelectCpuArch?: boolean,
-  ) {
+  async fetchCluster(ocmCluster: OcmClusterType, pullSecret: string, openshiftVersion: string) {
     const openshiftClusterId = Day2ClusterService.getOpenshiftClusterId(ocmCluster);
 
     if (!openshiftClusterId) {
@@ -63,24 +47,13 @@ const Day2ClusterService = {
       return Day2ClusterService.fetchClusterById(day2ClusterId);
     }
 
-    // The first time the user accesses "Add hosts" tab, the infraEnv(s) need to be created
-    const createMultipleInfraEnvs =
-      ocmCluster.cpu_architecture === OcmCpuArchitecture.MULTI || canSelectCpuArch;
-    const cpuArchitectures = createMultipleInfraEnvs
-      ? getSupportedCpuArchitectures(
-          canSelectCpuArch ? canSelectCpuArch : false,
-          cpuArchitecturesByVersionImage,
-          mapClusterCpuArchToInfraEnvCpuArch(ocmCluster.cpu_architecture),
-        )
-      : ([mapOcmArchToCpuArchitecture(ocmCluster.cpu_architecture)] as SupportedCpuArchitecture[]);
-
     return Day2ClusterService.createCluster(
       openshiftClusterId,
       ocmCluster.display_name || ocmCluster.name || openshiftClusterId,
       getApiVipDnsName(ocmCluster).apiVipDnsname,
       pullSecret,
       openshiftVersion,
-      cpuArchitectures,
+      mapOcmArchToCpuArchitecture(ocmCluster.cpu_architecture) as CpuArchitecture,
     );
   },
 
@@ -104,7 +77,7 @@ const Day2ClusterService = {
     apiVipDnsname: string,
     pullSecret: string,
     openshiftVersion: string,
-    cpuArchitectures: SupportedCpuArchitecture[],
+    cpuArchitecture: CpuArchitecture,
   ) {
     const { data: day2Cluster } = await ClustersAPI.registerAddHosts({
       openshiftClusterId, // used to both match OpenShift Cluster and as an assisted-installer ID
@@ -113,17 +86,14 @@ const Day2ClusterService = {
       openshiftVersion,
     });
 
-    // Create the infraEnvs for each cpuArchitecture
-    const infraEnvsToCreate = cpuArchitectures.map((cpuArchitecture) => {
-      return InfraEnvsService.create({
-        name: `${day2Cluster.name || ''}_infra-env-${cpuArchitecture}`,
-        pullSecret,
-        clusterId: day2Cluster.id,
-        openshiftVersion,
-        cpuArchitecture: cpuArchitecture as ClusterCpuArchitecture,
-      });
+    // Create only the infraenv for the day1 cpu architecture
+    await InfraEnvsService.create({
+      name: InfraEnvsService.makeInfraEnvName(cpuArchitecture, day2Cluster.name),
+      pullSecret,
+      clusterId: day2Cluster.id,
+      openshiftVersion,
+      cpuArchitecture: cpuArchitecture as ClusterCpuArchitecture,
     });
-    await Promise.all(infraEnvsToCreate);
 
     return day2Cluster;
   },

package/lib/ocm/services/InfraEnvIdsCacheService.ts

@@ -21,7 +21,7 @@ const read = (): InfraEnvCache => {
 };
 
 type InfraEnvStorage = Omit<Storage, 'getItem' | 'removeItem' | 'setItem'> & {
-  getInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): string | null;
+  getInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): string | Error;
   removeInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): void;
   removeInfraEnvs(clusterId: string): void;
   updateInfraEnvs(clusterId: string, infraEnvs: InfraEnv[]): void;
@@ -42,18 +42,21 @@ const InfraEnvIdsCacheService: InfraEnvStorage = {
     localStorage.removeItem(CACHE_KEY);
   },
 
-  getInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): string | null {
+  getInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): string | Error {
     if (!clusterId || !cpuArchitecture) {
-      return null;
+      return new Error(`clusterId or cpuArchitecture are missing`);
     }
 
     const cache = read();
     const clusterInfraEnvs = cache[clusterId];
     if (!clusterInfraEnvs) {
-      return null;
+      return new Error(`Not infraEnvs found for this cluster ${clusterId}`);
     }
-    if (cpuArchitecture !== CpuArchitecture.USE_DAY1_ARCHITECTURE) {
-      return clusterInfraEnvs[cpuArchitecture] || null;
+    if (
+      cpuArchitecture !== CpuArchitecture.USE_DAY1_ARCHITECTURE &&
+      cpuArchitecture !== CpuArchitecture.MULTI
+    ) {
+      return clusterInfraEnvs[cpuArchitecture] || new Error(`InfraEnv can't be found`);
     }
 
     const architectures = getAllCpuArchitectures().filter((arch) => {

package/lib/ocm/services/InfraEnvsService.ts

@@ -11,9 +11,12 @@ import InfraEnvCache from './InfraEnvIdsCacheService';
 import { getDummyInfraEnvField } from '../components/clusterConfiguration/staticIp/data/dummyData';
 
 const InfraEnvsService = {
-  async getInfraEnvId(clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture): Promise<string> {
+  async getInfraEnvId(
+    clusterId: Cluster['id'],
+    cpuArchitecture: CpuArchitecture,
+  ): Promise<string | Error> {
     let infraEnvId = InfraEnvCache.getInfraEnvId(clusterId, cpuArchitecture);
-    if (infraEnvId === null) {
+    if (infraEnvId instanceof Error) {
       const { data: infraEnvs } = await InfraEnvsAPI.list(clusterId);
       if (infraEnvs.length > 0) {
         InfraEnvCache.updateInfraEnvs(clusterId, infraEnvs);
@@ -21,11 +24,6 @@ const InfraEnvsService = {
       }
       if (!infraEnvId) {
         InfraEnvCache.removeInfraEnvId(clusterId, cpuArchitecture);
-        throw new Error(
-          `No InfraEnv could be found for clusterId: ${clusterId} and architecture ${
-            cpuArchitecture || ''
-          }`,
-        );
       }
     }
     return infraEnvId;
@@ -33,15 +31,11 @@ const InfraEnvsService = {
 
   async getInfraEnv(clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture) {
     const infraEnvId = await InfraEnvsService.getInfraEnvId(clusterId, cpuArchitecture);
-    if (infraEnvId) {
+    if (infraEnvId && !(infraEnvId instanceof Error)) {
       const { data } = await InfraEnvsAPI.get(infraEnvId);
       return data;
     } else {
-      throw new Error(
-        `No InfraEnv could be found for clusterId: ${clusterId} and architecture ${
-          cpuArchitecture || ''
-        }`,
-      );
+      return new Error(`Failed to retrieve the infraEnv for ${clusterId}`);
     }
   },
 
@@ -67,6 +61,7 @@ const InfraEnvsService = {
     }
 
     InfraEnvCache.updateInfraEnvs(params.clusterId, [infraEnv]);
+    return infraEnv;
   },
 
   async removeAll(clusterId: Cluster['id']) {
@@ -126,6 +121,10 @@ const InfraEnvsService = {
       return updatedInfraEnv;
     });
   },
+
+  makeInfraEnvName(cpuArchitecture: string, name?: string) {
+    return `${name || ''}_infra-env-${cpuArchitecture}`;
+  },
 };
 
 export default InfraEnvsService;

package/lib/ocm/services/apis/EventsAPI.ts

@@ -1,11 +1,23 @@
 import { EventList, V2Events } from '../../../common';
 import { client } from '../../api';
 
+let _getRequestAbortController = new AbortController();
+
 const EventsAPI = {
   makeBaseURI() {
     return '/v2/events';
   },
 
+  abort() {
+    _getRequestAbortController.abort();
+    /*
+     * The AbortController.signal can only be aborted once per instance.
+     * Therefore in order for other requests to be also abortable we need
+     * to create a new instance when this event occurs
+     */
+    _getRequestAbortController = new AbortController();
+  },
+
   createParams({
     clusterId,
     hostIds,
@@ -36,7 +48,9 @@ const EventsAPI = {
   },
 
   list(options: V2Events) {
-    return client.get<EventList>(`${EventsAPI.makeBaseURI()}${EventsAPI.createParams(options)}`);
+    return client.get<EventList>(`${EventsAPI.makeBaseURI()}${EventsAPI.createParams(options)}`, {
+      signal: _getRequestAbortController.signal,
+    });
   },
 };
 

package/package.json

@@ -130,5 +130,5 @@
       ]
     }
   },
-  "version": "2.8.2-cim"
+  "version": "2.9.0-cim"
 }