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

package/lib/common/components/newFeatureSupportLevels/FeatureSupportLevelBadge.tsx

@@ -1,34 +0,0 @@
-import React from 'react';
-import { SupportLevel } from '../../api/types';
-import { FeatureId, isPreviewSupportLevel } from '../../types';
-import { TechnologyPreview, DeveloperPreview } from '../ui/PreviewBadge';
-import { useNewFeatureSupportLevel } from './FeatureSupportLevelContext';
-
-export type NewSupportLevelBadgeProps = {
-  featureId: FeatureId;
-  openshiftVersion: string | undefined;
-};
-
-const NewFeatureSupportLevelBadge: React.FC<NewSupportLevelBadgeProps> = ({
-  featureId,
-  openshiftVersion,
-}) => {
-  const featureSupportLevelData = useNewFeatureSupportLevel();
-  const supportLevel: SupportLevel | undefined = React.useMemo(() => {
-    if (!openshiftVersion) {
-      return undefined;
-    }
-    return featureSupportLevelData.getFeatureSupportLevel(featureId);
-  }, [openshiftVersion, featureId, featureSupportLevelData]);
-  if (!isPreviewSupportLevel(supportLevel)) {
-    return null;
-  }
-  const testId = `${featureId}-support-level`;
-  return supportLevel === 'tech-preview' ? (
-    <TechnologyPreview testId={testId} />
-  ) : (
-    <DeveloperPreview testId={testId} />
-  );
-};
-
-export default NewFeatureSupportLevelBadge;

package/lib/common/components/newFeatureSupportLevels/FeatureSupportLevelContext.tsx

@@ -1,44 +0,0 @@
-import React from 'react';
-import { TFunction } from 'i18next';
-
-import { CpuArchitecture, FeatureId } from '../../types';
-import { useTranslation } from '../../hooks/use-translation-wrapper';
-import { SupportLevel, SupportLevels } from '../../api';
-
-export type ActiveFeatureConfiguration = {
-  underlyingCpuArchitecture: CpuArchitecture;
-  hasStaticIpNetworking: boolean;
-};
-
-export type NewFeatureSupportLevelData = {
-  getFeatureSupportLevels(): SupportLevels;
-  getFeatureSupportLevel(featureId: FeatureId): SupportLevel | undefined;
-  isFeatureDisabled(featureId: FeatureId): boolean;
-  getFeatureDisabledReason(featureId: FeatureId, t?: TFunction): string | undefined;
-  isFeatureSupported(featureId: FeatureId): boolean;
-  activeFeatureConfiguration?: ActiveFeatureConfiguration;
-};
-
-const NewFeatureSupportLevelContext = React.createContext<NewFeatureSupportLevelData | null>(null);
-
-export const NewFeatureSupportLevelContextProvider: React.FC<{
-  children: React.ReactNode;
-  value: NewFeatureSupportLevelData;
-}> = ({ value, children }) => {
-  return (
-    <NewFeatureSupportLevelContext.Provider value={value}>
-      {children}
-    </NewFeatureSupportLevelContext.Provider>
-  );
-};
-
-export const useNewFeatureSupportLevel = () => {
-  const context = React.useContext(NewFeatureSupportLevelContext);
-  const { t } = useTranslation();
-  if (!context) {
-    throw new Error(
-      t('ai:useNewFeatureSupportLevel must be used within NewFeatureSupportLevelContextProvider.'),
-    );
-  }
-  return context;
-};

package/lib/ocm/api/axiosClient.ts

@@ -1,52 +0,0 @@
-import axios, { AxiosInstance } from 'axios';
-import applyCaseMiddleware from 'axios-case-converter';
-import { camelCase } from 'camel-case';
-
-// conforms basePath in swagger.json
-export const BASE_PATH = '/api/assisted-install';
-
-// Prevent axios converter to change object keys from '4.7-fc2' to '4_7Fc2'
-const axiosCaseConverterOptions = {
-  caseFunctions: {
-    camel: (input: string) =>
-      camelCase(input, {
-        stripRegexp: /[^A-Z0-9.-]+/gi,
-      }),
-  },
-};
-
-const getDefaultClient = (withoutConverter = false) => {
-  const client = axios.create();
-  client.interceptors.request.use((cfg) => ({
-    ...cfg,
-    url: `${process.env.AIUI_APP_API_ROOT || ''}${cfg.url || ''}`,
-  }));
-  if (withoutConverter) {
-    return client;
-  } else {
-    return applyCaseMiddleware(client, axiosCaseConverterOptions);
-  }
-};
-
-let client: AxiosInstance = getDefaultClient();
-let clientWithoutConverter: AxiosInstance = getDefaultClient(true);
-let ocmClient: AxiosInstance | null;
-
-const aiInterceptor = (client: AxiosInstance) => {
-  client.interceptors.request.use((cfg) => ({
-    ...cfg,
-    url: `${BASE_PATH}${cfg.url || ''}`,
-  }));
-  return client;
-};
-
-export const setAuthInterceptor = (authInterceptor: (client: AxiosInstance) => AxiosInstance) => {
-  ocmClient = authInterceptor(axios.create());
-  client = applyCaseMiddleware(
-    aiInterceptor(authInterceptor(axios.create())),
-    axiosCaseConverterOptions,
-  );
-  clientWithoutConverter = aiInterceptor(authInterceptor(axios.create()));
-};
-
-export { client, ocmClient, clientWithoutConverter };

package/lib/ocm/api/axiosExtensions.ts

@@ -1,11 +0,0 @@
-import { AxiosError } from 'axios';
-import { hasProp, isNonNullObject } from '../../common/types';
-
-// Implementation from Axios.isAxiosError v0.29.2, which is not available in OCM's version 0.17.x
-export function isAxiosError<T = unknown, D = unknown>(
-  payload: unknown,
-): payload is AxiosError<T, D> {
-  return (
-    isNonNullObject(payload) && hasProp(payload, 'isAxiosError') && payload.isAxiosError === true
-  );
-}

package/lib/ocm/api/types.ts

@@ -1,13 +0,0 @@
-import { AxiosError } from 'axios';
-import { isAxiosError } from './axiosExtensions';
-import { Error as APIError, InfraError } from '../../common/api/types';
-
-export type APIErrorMixin = InfraError & APIError;
-export type AIAxiosErrorType = AxiosError<APIErrorMixin, APIErrorMixin>;
-
-export const isApiError = (error: unknown): error is AIAxiosErrorType => {
-  if (!isAxiosError<AIAxiosErrorType, AIAxiosErrorType>(error)) {
-    return false;
-  }
-  return typeof error.response?.data === 'object';
-};

package/lib/ocm/api/utils.ts

@@ -1,86 +0,0 @@
-import Axios, { AxiosError } from 'axios';
-import { Severity } from '@sentry/browser';
-import pick from 'lodash-es/pick.js';
-import { captureException } from '../sentry';
-import { isApiError } from './types';
-import { getErrorMessage } from '../../common/utils';
-import { isAxiosError } from './axiosExtensions';
-
-export const FETCH_ABORTED_ERROR_CODE = 'ERR_CANCELED';
-export const FETCH_CONNECTIVITY_ERROR_CODE = 'CONNECTIVITY_ERROR';
-export const SERVER_ERROR_CODE = 'SERVER_ERROR';
-export const PAGE_RELOAD_ERROR = 'ECONNABORTED';
-
-type OnError = (arg0: unknown) => void;
-
-export const handleApiError = (error: unknown, onError?: OnError): void => {
-  if (Axios.isCancel(error)) {
-    captureException(error, 'Request canceled', Severity.Info);
-  } else if (isApiError(error)) {
-    const config = error.config || { url: '', method: '' };
-    let message = `URL: ${JSON.stringify(config.url, null, 1)}\n`;
-    message += `Method: ${JSON.stringify(config.method, null, 1)}\n`;
-    if (error.response) {
-      // The request was made and the server responded with a status code
-      // that falls out of the range of 2xx
-      message += `Status: ${error.response.status}\n`;
-      message += `Response: ${JSON.stringify(
-        pick(error.response.data, ['code', 'message', 'reason']),
-        null,
-        1,
-      )}\n`;
-    } else if (error.request) {
-      // The request was made but no response was received
-      // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
-      // http.ClientRequest in node.js
-      message += `Status Code: ${JSON.stringify(
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        error.request.__sentry_xhr__.status_code,
-        null,
-        1,
-      )}`;
-    }
-    captureException(error, message);
-  } else {
-    captureException(error);
-  }
-  if (onError) return onError(error);
-};
-
-export const getApiErrorMessage = (error: unknown): string => {
-  if (isApiError(error)) {
-    return error.response?.data?.message || error.response?.data.reason || error.message;
-  }
-  return getErrorMessage(error);
-};
-
-export const isUnknownServerError = (error: Error): boolean => {
-  return getApiErrorCode(error) === SERVER_ERROR_CODE;
-};
-
-export const getApiErrorCode = (error: Error | AxiosError): string | number => {
-  if (!isAxiosError(error)) {
-    return FETCH_CONNECTIVITY_ERROR_CODE;
-  }
-  // Aborted request
-  if (error.code === FETCH_ABORTED_ERROR_CODE) {
-    return FETCH_ABORTED_ERROR_CODE;
-  }
-
-  // Page is reloading and some request has been interrupted
-  if (error.code === PAGE_RELOAD_ERROR) {
-    return '';
-  }
-
-  const responseStatus = error.response?.status || 0;
-
-  // Error status
-  if (responseStatus >= 500 && responseStatus < 600) {
-    return SERVER_ERROR_CODE;
-  }
-  if (responseStatus >= 400 && responseStatus < 500) {
-    return responseStatus;
-  }
-  // A generic connectivity issue
-  return FETCH_CONNECTIVITY_ERROR_CODE;
-};

package/lib/ocm/components/Router.tsx

@@ -1,29 +0,0 @@
-import React from 'react';
-import { Provider } from 'react-redux';
-import { Switch, Route, Redirect } from 'react-router-dom';
-import { Clusters, ClusterPage, NewClusterPage } from './clusters';
-import { store } from '../store';
-import { FeatureGateContextProvider, FeatureListType } from '../../common';
-import { routeBasePath } from '../config';
-import { AssistedUILibVersion } from './ui';
-
-export const AssistedUiRouter: React.FC<{ allEnabledFeatures: FeatureListType }> = ({
-  allEnabledFeatures,
-}) => (
-  <Provider store={store}>
-    <Router features={allEnabledFeatures} />
-  </Provider>
-);
-
-export const Router: React.FC<{ features: FeatureListType }> = ({ features, children }) => (
-  <FeatureGateContextProvider features={features}>
-    <AssistedUILibVersion />
-    <Switch>
-      <Route path={`${routeBasePath}/clusters/~new`} component={NewClusterPage} />
-      <Route path={`${routeBasePath}/clusters/:clusterId`} component={ClusterPage} />
-      <Route path={`${routeBasePath}/clusters`} component={Clusters} />
-      {children}
-      <Redirect to={`${routeBasePath}/clusters`} />
-    </Switch>
-  </FeatureGateContextProvider>
-);

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

@@ -1,72 +0,0 @@
-import React from 'react';
-
-import { OcmSwitchField } from '../../ui/OcmFormFields';
-import { Cluster, PopoverIcon } from '../../../../common';
-import useClusterSupportedPlatforms, {
-  SupportedPlatformIntegrationType,
-} from '../../../hooks/useClusterSupportedPlatforms';
-import PlatformIntegrationVsphere from './PlatformIntegrationVsphere';
-import { SplitItem, Text } from '@patternfly/react-core';
-import { useNewFeatureSupportLevel } from '../../../../common/components/newFeatureSupportLevels';
-
-type KeyType = Record<SupportedPlatformIntegrationType, string>;
-
-const undeterminedPlatformMessage =
-  'Enable platform integration to access features directly in OpenShift, like vSphere node auto-scaling and persistent storage or Nutanix node auto-scaling.';
-const vspherePlatformMessage =
-  "Enable vSphere platform integration to access features directly inside OpenShift, like node auto-scaling and persistent storage. You'll need to set vSphere configuration after cluster installation is complete.";
-
-const nutanixPlatformMessage =
-  'Enable Nutanix platform integration to access features like node auto-scaling directly inside OpenShift.';
-
-const platformIntegrationTooltip =
-  '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,
-  vsphere: vspherePlatformMessage,
-  nutanix: nutanixPlatformMessage,
-};
-
-const PlatformIntegration = ({ clusterId }: { clusterId: Cluster['id'] }) => {
-  const { isPlatformIntegrationSupported, supportedPlatformIntegration } =
-    useClusterSupportedPlatforms(clusterId);
-
-  const featureSupportLevels = useNewFeatureSupportLevel();
-  const isNutanixFeatureSupported = featureSupportLevels.isFeatureSupported('NUTANIX_INTEGRATION');
-
-  return (
-    <>
-      <SplitItem>
-        <OcmSwitchField
-          tooltipProps={{
-            hidden: isPlatformIntegrationSupported,
-            content: platformIntegrationTooltip,
-          }}
-          isDisabled={
-            !isPlatformIntegrationSupported ||
-            (supportedPlatformIntegration === 'nutanix' && !isNutanixFeatureSupported)
-          }
-          name={'usePlatformIntegration'}
-          label="Integrate with your virtualization platform&nbsp;"
-          switchOuiaId="platform-integration-vSphere-switch"
-        />
-      </SplitItem>
-      <SplitItem>
-        <PopoverIcon
-          minWidth="22rem"
-          bodyContent={
-            <>
-              <Text>{messages[supportedPlatformIntegration]}</Text>
-              {supportedPlatformIntegration === 'vsphere' && <PlatformIntegrationVsphere />}
-            </>
-          }
-          buttonOuiaId="platform-integration-vSphere-popover"
-          buttonStyle={{ marginTop: '4px' }}
-        />
-      </SplitItem>
-    </>
-  );
-};
-
-export default PlatformIntegration;

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

@@ -1,24 +0,0 @@
-import React from 'react';
-import { List, ListItem, Title } from '@patternfly/react-core';
-import { VSPHERE_CONFIG_LINK } from '../../../../common';
-
-const PlatformIntegrationVsphere = () => {
-  return (
-    <>
-      <Title headingLevel="h6">Requirements</Title>
-      <List>
-        <ListItem>vSphere 7.0.2 and above</ListItem>
-        <ListItem>A network connection between vSphere and the installed OCP.</ListItem>
-        <ListItem>
-          Ensure clusterSet <code>disk.enableUUID</code> is set to <code>true</code> inside of
-          vSphere
-        </ListItem>
-      </List>
-      <a href={VSPHERE_CONFIG_LINK} target="_blank" rel="noopener noreferrer">
-        {'Learn more about vSphere platform integration'}
-      </a>
-    </>
-  );
-};
-
-export default PlatformIntegrationVsphere;

package/lib/ocm/components/clusterWizard/ClusterPlatformIntegrationHint.tsx

@@ -1,63 +0,0 @@
-import React from 'react';
-import { Alert, AlertVariant } from '@patternfly/react-core';
-import { useClusterSupportedPlatforms } from '../../hooks';
-import {
-  isClusterPlatformTypeVM,
-  NUTANIX_CONFIG_LINK,
-  PlatformType,
-  SupportedPlatformType,
-  VSPHERE_CONFIG_LINK,
-} from '../../../common';
-import { useNewFeatureSupportLevel } from '../../../common/components/newFeatureSupportLevels';
-
-type ClusterPlatformIntegrationHintProps = {
-  clusterId: string;
-  platformType: PlatformType;
-};
-
-const integrationBrands: Record<SupportedPlatformType, string> = {
-  vsphere: 'vSphere',
-  nutanix: 'Nutanix',
-};
-
-export const integrationPlatformLinks: Record<SupportedPlatformType, string> = {
-  vsphere: VSPHERE_CONFIG_LINK,
-  nutanix: NUTANIX_CONFIG_LINK,
-};
-
-export const ClusterPlatformIntegrationHint = ({
-  clusterId,
-  platformType,
-}: ClusterPlatformIntegrationHintProps) => {
-  const { isPlatformIntegrationSupported, supportedPlatformIntegration } =
-    useClusterSupportedPlatforms(clusterId);
-
-  const featureSupportLevels = useNewFeatureSupportLevel();
-  const isNutanixFeatureSupported =
-    featureSupportLevels.isFeatureSupported('NUTANIX_INTEGRATION') ?? false;
-  const canIntegrateWithPlatform =
-    isPlatformIntegrationSupported &&
-    !isClusterPlatformTypeVM({ platform: { type: platformType } });
-
-  if (!canIntegrateWithPlatform) {
-    return null;
-  }
-
-  //Not show nutanix message in host discovery step when nutanix is not supported
-  if (supportedPlatformIntegration === 'nutanix' && !isNutanixFeatureSupported) {
-    return null;
-  }
-
-  const integrationBrand = integrationBrands[supportedPlatformIntegration as SupportedPlatformType];
-
-  return (
-    <Alert
-      title={`Discover the full potential of ${integrationBrand} integration`}
-      variant={AlertVariant.info}
-      isInline
-      data-testid="discover-platform-integration-hosts"
-    >
-      {`Since all of your hosts originated from the ${integrationBrand} platform, you now have the option to integrate with it.`}
-    </Alert>
-  );
-};

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

@@ -1,151 +0,0 @@
-import React, { PropsWithChildren } from 'react';
-import {
-  ActiveFeatureConfiguration,
-  Cluster,
-  CpuArchitecture,
-  FeatureId,
-  getDefaultCpuArchitecture,
-  SupportLevel,
-  SupportLevels,
-} from '../../../common';
-import { useOpenshiftVersions, usePullSecret } from '../../hooks';
-import {
-  getNewFeatureDisabledReason,
-  isFeatureSupportedAndAvailable,
-} from './newFeatureStateUtils';
-import useInfraEnv from '../../hooks/useInfraEnv';
-import {
-  NewFeatureSupportLevelContextProvider,
-  NewFeatureSupportLevelData,
-  NewFeatureSupportLevelMap,
-} from '../../../common/components/newFeatureSupportLevels';
-import useSupportLevelsAPI from '../../hooks/useSupportLevelsAPI';
-import { TFunction } from 'i18next';
-
-export type NewSupportLevelProviderProps = PropsWithChildren<{
-  clusterFeatureUsage?: string;
-  openshiftVersion?: string;
-  loadingUi: React.ReactNode;
-  cluster?: Cluster;
-  cpuArchitecture?: string;
-}>;
-
-export const getFeatureSupported = (featureSupportLevels: SupportLevels, featureId: FeatureId) => {
-  return featureSupportLevels && isFeatureSupportedAndAvailable(featureSupportLevels[featureId]);
-};
-
-export const NewFeatureSupportLevelProvider: React.FC<NewSupportLevelProviderProps> = ({
-  cluster,
-  children,
-  loadingUi,
-  cpuArchitecture,
-  openshiftVersion,
-}) => {
-  const { loading: loadingOCPVersions } = useOpenshiftVersions();
-  const pullSecret = usePullSecret();
-  const { infraEnv, isLoading: isInfraEnvLoading } = useInfraEnv(
-    cluster?.id || '',
-    cluster?.cpuArchitecture ? (cluster.cpuArchitecture as CpuArchitecture) : CpuArchitecture.x86,
-    cluster?.name,
-    pullSecret,
-    cluster?.openshiftVersion,
-  );
-  const featureSupportLevels = useSupportLevelsAPI('features', openshiftVersion, cpuArchitecture);
-
-  const supportLevelData = React.useMemo<NewFeatureSupportLevelMap>(() => {
-    if (!featureSupportLevels) {
-      return {} as NewFeatureSupportLevelMap;
-    }
-    return featureSupportLevels;
-  }, [featureSupportLevels]);
-
-  const isLoading = !supportLevelData || loadingOCPVersions || isInfraEnvLoading;
-
-  const activeFeatureConfiguration = React.useMemo<ActiveFeatureConfiguration>(
-    () => ({
-      underlyingCpuArchitecture: (infraEnv?.cpuArchitecture ||
-        cluster?.cpuArchitecture ||
-        getDefaultCpuArchitecture()) as CpuArchitecture,
-      hasStaticIpNetworking: !!infraEnv?.staticNetworkConfig,
-    }),
-    [cluster?.cpuArchitecture, infraEnv?.cpuArchitecture, infraEnv?.staticNetworkConfig],
-  );
-
-  const getFeatureSupportLevels = React.useCallback((): NewFeatureSupportLevelMap => {
-    return supportLevelData;
-  }, [supportLevelData]);
-
-  const getFeatureSupportLevel = React.useCallback(
-    (
-      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;
-        }
-      }
-    },
-    [supportLevelData],
-  );
-
-  const isFeatureSupportedCallback = React.useCallback(
-    (featureId: FeatureId, supportLevelDataNew?: NewFeatureSupportLevelMap) => {
-      const supportLevel = getFeatureSupportLevel(featureId, supportLevelDataNew);
-      return isFeatureSupportedAndAvailable(supportLevel);
-    },
-    [getFeatureSupportLevel],
-  );
-
-  const getDisabledReasonCallback = React.useCallback(
-    (featureId: FeatureId, t?: TFunction, supportLevelDataNew?: NewFeatureSupportLevelMap) => {
-      const isSupported = isFeatureSupportedCallback(featureId, supportLevelDataNew);
-      return getNewFeatureDisabledReason(
-        featureId,
-        cluster,
-        activeFeatureConfiguration,
-        isSupported,
-      );
-    },
-    [isFeatureSupportedCallback, cluster, activeFeatureConfiguration],
-  );
-
-  const isFeatureDisabled = React.useCallback(
-    (featureId: FeatureId, supportLevelDataNew?: NewFeatureSupportLevelMap) =>
-      !!getDisabledReasonCallback(featureId, undefined, supportLevelDataNew),
-    [getDisabledReasonCallback],
-  );
-
-  const providerValue = React.useMemo<NewFeatureSupportLevelData>(() => {
-    return {
-      getFeatureSupportLevels: getFeatureSupportLevels,
-      getFeatureSupportLevel: getFeatureSupportLevel,
-      isFeatureDisabled: isFeatureDisabled,
-      getFeatureDisabledReason: getDisabledReasonCallback,
-      isFeatureSupported: isFeatureSupportedCallback,
-      activeFeatureConfiguration,
-    };
-  }, [
-    getFeatureSupportLevels,
-    getFeatureSupportLevel,
-    isFeatureDisabled,
-    getDisabledReasonCallback,
-    isFeatureSupportedCallback,
-    activeFeatureConfiguration,
-  ]);
-
-  return (
-    <NewFeatureSupportLevelContextProvider value={providerValue}>
-      {isLoading ? loadingUi : children}
-    </NewFeatureSupportLevelContextProvider>
-  );
-};
-
-export default NewFeatureSupportLevelProvider;