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

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,15 @@ 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.USE_DAY1_ARCHITECTURE,
+    cluster?.name,
+    pullSecret,
+    cluster?.openshiftVersion,
   );
 
   if (!cluster || cluster.status === 'adding-hosts') {
@@ -52,7 +59,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/clusterWizard/ClusterWizardContextProvider.tsx

@@ -16,9 +16,11 @@ import {
   InfraEnv,
   AssistedInstallerOCMPermissionTypesListType,
   useFeature,
+  useAlerts,
 } from '../../../common';
 import useSetClusterPermissions from '../../hooks/useSetClusterPermissions';
 import useClusterCustomManifests from '../../hooks/useClusterCustomManifests';
+import { ListManifestsExtended } from '../clusterConfiguration/manifestsConfiguration/data/dataTypes';
 
 const addStepToClusterWizard = (
   wizardStepIds: ClusterWizardStepsType[],
@@ -77,6 +79,15 @@ const getWizardStepIds = (
   return stepsCopy;
 };
 
+const validateIfCustomsManifestsNeedsToBeFilled = (
+  customManifests: ListManifestsExtended,
+): boolean => {
+  const customManifestsEmpty = customManifests.filter(
+    (customManifest) => customManifest.yamlContent === '',
+  );
+  return customManifestsEmpty.length > 0;
+};
+
 const ClusterWizardContextProvider = ({
   children,
   cluster,
@@ -91,18 +102,23 @@ const ClusterWizardContextProvider = ({
   const [wizardStepIds, setWizardStepIds] = React.useState<ClusterWizardStepsType[]>();
   const [addCustomManifests, setAddCustomManifests] = React.useState<boolean>(false);
   const { state: locationState } = useLocation<ClusterWizardFlowStateType>();
-  const { customManifests } = useClusterCustomManifests(cluster?.id || '', false);
+  const { customManifests } = useClusterCustomManifests(cluster?.id || '', true);
   const setClusterPermissions = useSetClusterPermissions();
   const isSingleClusterFeatureEnabled = useFeature('ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE');
-
+  const { clearAlerts } = useAlerts();
   React.useEffect(() => {
     const staticIpInfo = infraEnv ? getStaticIpInfo(infraEnv) : undefined;
+    const customManifestsStepNeedsToBeFilled =
+      customManifests && customManifests.length > 0
+        ? validateIfCustomsManifestsNeedsToBeFilled(customManifests)
+        : false;
     const firstStep = getClusterWizardFirstStep(
       locationState,
       staticIpInfo,
       cluster?.status,
       cluster?.hosts,
       isSingleClusterFeatureEnabled,
+      customManifestsStepNeedsToBeFilled,
     );
     const firstStepIds = getWizardStepIds(
       wizardStepIds,
@@ -156,6 +172,7 @@ const ClusterWizardContextProvider = ({
     };
     return {
       moveBack(): void {
+        clearAlerts();
         const currentStepIdx = wizardStepIds.indexOf(currentStepId);
         let nextStepId = wizardStepIds[currentStepIdx - 1];
         if (nextStepId === 'static-ip-host-configurations') {
@@ -213,6 +230,7 @@ const ClusterWizardContextProvider = ({
     addCustomManifests,
     customManifests,
     isSingleClusterFeatureEnabled,
+    clearAlerts,
   ]);
   if (!contextValue) {
     return null;

package/lib/ocm/components/clusterWizard/wizardTransition.ts

@@ -32,12 +32,23 @@ export type ClusterWizardStepsType =
 export const ClusterWizardFlowStateNew = 'new';
 export type ClusterWizardFlowStateType = Cluster['status'] | typeof ClusterWizardFlowStateNew;
 
+export const getLastStepForWizard = (
+  customManifestsStepNeedsToBeFilled: boolean,
+): ClusterWizardStepsType => {
+  if (customManifestsStepNeedsToBeFilled) {
+    return 'custom-manifests';
+  } else {
+    return 'review';
+  }
+};
+
 export const getClusterWizardFirstStep = (
   locationState: ClusterWizardFlowStateType | undefined,
   staticIpInfo: StaticIpInfo | undefined,
   state?: ClusterWizardFlowStateType,
   hosts?: Host[] | undefined,
   isSingleClusterFeatureEnabled?: boolean,
+  customManifestsStepNeedsToBeFilled?: boolean,
 ): ClusterWizardStepsType => {
   // Just for the first time when the cluster is created
   if (locationState === ClusterWizardFlowStateNew && !staticIpInfo) {
@@ -53,9 +64,10 @@ export const getClusterWizardFirstStep = (
     }
     return 'static-ip-network-wide-configurations';
   }
+
   switch (state) {
     case 'ready':
-      return 'review';
+      return getLastStepForWizard(customManifestsStepNeedsToBeFilled || false);
     case 'pending-for-input':
     case 'adding-hosts':
     case 'insufficient':

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,21 @@ 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.USE_DAY1_ARCHITECTURE,
+    cluster?.name,
+    pullSecret,
+    cluster?.openshiftVersion,
+  );
 
   const getContent = (cluster: Cluster, infraEnv: InfraEnv) => {
     if (cluster.status === 'adding-hosts') {
@@ -188,8 +198,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,15 @@ 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.USE_DAY1_ARCHITECTURE,
+    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,6 +1,25 @@
-import { EventListFetchProps } from '../../../common';
+import { AxiosError, AxiosResponseHeaders } from 'axios';
+import { EVENT_SEVERITIES, Event, EventListFetchProps } from '../../../common';
 import { handleApiError } from '../../api';
 import { EventsAPI } from '../../services/apis';
+import { SeverityCountsType } from '../../../common/components/ui/ClusterEventsToolbar';
+
+const parseHeaders = (headers: AxiosResponseHeaders) => {
+  const severities: Record<Event['severity'], number> = {
+    error: 0,
+    info: 0,
+    warning: 0,
+    critical: 0,
+  };
+  EVENT_SEVERITIES.forEach((severity) => {
+    const count = Number(headers[`severity-count-${severity}`]);
+    severities[severity] = count;
+  });
+  return {
+    totalEvents: Number(headers['event-count']),
+    severities: severities as SeverityCountsType,
+  };
+};
 
 export const onFetchEvents: EventListFetchProps['onFetchEvents'] = async (
   props,
@@ -8,11 +27,18 @@ 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');
+    onSuccess({
+      data: response.data,
+      ...parseHeaders(response.headers),
     });
+  } catch (error) {
+    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,15 @@ 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.USE_DAY1_ARCHITECTURE,
+    cluster?.name,
+    pullSecret,
+    cluster?.openshiftVersion,
   );
   const featureSupportLevels = useSupportLevelsAPI('features', openshiftVersion, cpuArchitecture);
 

package/lib/ocm/hooks/useClusterCustomManifests.ts

@@ -45,7 +45,11 @@ const getManifestsInfo = async (customManifests: ListManifests, clusterId: strin
   return manifestsExtended;
 };
 
-const useClusterCustomManifests = (clusterId: Cluster['id'], extendedVersion: boolean) => {
+const useClusterCustomManifests = (
+  clusterId: Cluster['id'],
+  extendedVersion: boolean,
+  refresh = true,
+) => {
   const [customManifests, setCustomManifests] = React.useState<ListManifestsExtended>();
   const [error, setError] = React.useState('');
   const [extendedManifestsLoaded, setExtendedManifestsLoaded] = React.useState<boolean>(false);
@@ -81,8 +85,10 @@ const useClusterCustomManifests = (clusterId: Cluster['id'], extendedVersion: bo
   }, [clusterId, extendedVersion]);
 
   React.useEffect(() => {
-    void fetchCustomManifests();
-  }, [fetchCustomManifests]);
+    if (refresh) {
+      void fetchCustomManifests();
+    }
+  }, [fetchCustomManifests, refresh]);
 
   return {
     customManifests,

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/ClustersService.ts

@@ -96,7 +96,7 @@ const ClustersService = {
     return {
       folder: manifest.folder,
       fileName: manifest.filename,
-      content: Buffer.from(manifest.manifestYaml).toString('base64'),
+      content: window.btoa(manifest.manifestYaml),
     };
   },
 
@@ -109,7 +109,7 @@ const ClustersService = {
       fileName: existingManifest.filename,
       updatedFolder: updatedManifest.folder,
       updatedFileName: updatedManifest.filename,
-      updatedContent: Buffer.from(updatedManifest.manifestYaml).toString('base64'),
+      updatedContent: window.btoa(updatedManifest.manifestYaml),
     };
   },
 

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,
+    });
   },
 };