@openshift-assisted/ui-lib 2.52.2 → 5.0.0-cim

package/lib/cim/components/modals/CimConfiguration/persist.ts

@@ -4,8 +4,8 @@ import {
   k8sListItems,
   k8sPatch,
   K8sResourceCommon,
+  Patch,
 } from '@openshift-console/dynamic-plugin-sdk';
-import { AlertVariant } from '@patternfly/react-core';
 import { TFunction } from 'i18next';
 import { getErrorMessage } from '../../../../common/utils';
 
@@ -13,42 +13,21 @@ import {
   AgentServiceConfigK8sResource,
   AgentServiceConfigModel,
   IngressControllerModel,
-  K8sPatch,
   ProvisioningModel,
   RouteK8sResource,
   RouteModel,
 } from '../../../types';
-import { LOCAL_STORAGE_ID_LAST_UPDATE_TIMESTAMP } from './utils';
 import { appendPatch } from '../../../utils';
-
-export type SetErrorFuncType = ({
-  title,
-  message,
-  variant,
-}: {
-  title: string;
-  message?: string;
-  variant?: AlertVariant;
-}) => void;
+import { CimConfigurationValues } from './types';
 
 const ASSISTED_IMAGE_SERVICE_ROUTE_PREFIX = 'assisted-image-service-multicluster-engine';
 
-// Since we do not know MCE's namespace, query all routes,
-// Find assisted-image-service's one and parse domain from there.
-const getAssistedImageServiceRoute = async (
-  t: TFunction,
-  setError: SetErrorFuncType,
-): Promise<RouteK8sResource | undefined> => {
+const getAssistedImageServiceRoute = async (t: TFunction): Promise<RouteK8sResource> => {
   let allRoutes: RouteK8sResource[] = [];
   try {
     allRoutes = await k8sListItems({ model: RouteModel, queryParams: {} });
   } catch (e) {
-    // console.error('Failed to read all routes: ', allRoutes);
-    setError({
-      title: t('ai:Failed to save configuration'),
-      message: t('ai:Can not query routes.'),
-    });
-    return undefined;
+    throw new Error(`${t('ai:Failed to save configuration')}: ${getErrorMessage(e)}`);
   }
 
   const assistedImageServiceRoute = allRoutes?.find(
@@ -56,54 +35,41 @@ const getAssistedImageServiceRoute = async (
   );
 
   if (!assistedImageServiceRoute?.spec?.host) {
-    setError({
-      title: t('ai:Failed to save configuration'),
-      message: t('ai:Can not find host of the assisted-image-service route'),
-    });
-    return undefined;
+    throw new Error(
+      `${t('ai:Failed to save configuration')}: ${t(
+        'ai:Can not find host of the assisted-image-service route',
+      )}`,
+    );
   }
 
   return assistedImageServiceRoute;
 };
 
-// There are many ways how to get the domain name, let's follow the documentation.
-const getClusterDomain = (
-  t: TFunction,
-  setError: SetErrorFuncType,
-  assistedImageServiceRoute: RouteK8sResource,
-): string | undefined => {
+const getClusterDomain = (t: TFunction, assistedImageServiceRoute: RouteK8sResource) => {
   const prefix = `${ASSISTED_IMAGE_SERVICE_ROUTE_PREFIX}.`;
   const host: string = assistedImageServiceRoute.spec?.host || '';
   const appsDomain = host.substring(host.indexOf(prefix) + prefix.length);
 
-  // the appsDomain can be prefixed either by "apps." or "nlb-apps." so search for first dot
   const domain = appsDomain.substring(appsDomain.indexOf('.') + 1);
 
   if (!domain) {
-    // It must be present
-    // console.error('Can not find domain in assistedImageServiceRoute: ', assistedImageServiceRoute);
-    setError({
-      title: t('ai:Can not find cluster domain.'),
-    });
+    throw new Error(t('ai:Can not find cluster domain.'));
   }
 
   return domain;
 };
 
-// Keep this function in sync with getClusterDomain()
 const patchAssistedImageServiceRoute = async (
   t: TFunction,
-  setError: SetErrorFuncType,
-
   assistedImageServiceRoute: RouteK8sResource,
   domain: string,
-): Promise<boolean> => {
+) => {
   const newHost = `${ASSISTED_IMAGE_SERVICE_ROUTE_PREFIX}.nlb-apps.${domain}`;
 
   const labels = assistedImageServiceRoute.metadata?.labels || {};
   labels['router-type'] = 'nlb';
 
-  const patches = [
+  const patches: Patch[] = [
     {
       op: 'replace',
       path: '/spec/host',
@@ -123,38 +89,28 @@ const patchAssistedImageServiceRoute = async (
       data: patches,
     });
   } catch (e) {
-    // console.error('Failed to patch assisted-image-service route: ', e, patches);
-    setError({
-      title: t('ai:Failed to patch assisted-image-service route for new domain.'),
-    });
-    return false;
+    throw new Error(
+      `${t('ai:Failed to patch assisted-image-service route for new domain.')}: ${getErrorMessage(
+        e,
+      )}`,
+    );
   }
-
-  return true;
 };
 
-export const isIngressController = async (): Promise<boolean> => {
+export async function isIngressController() {
   try {
     await k8sGet({
       name: 'ingress-controller-with-nlb',
       ns: 'openshift-ingress-operator',
       model: IngressControllerModel,
     });
-
     return true;
   } catch {
     return false;
   }
-};
-
-const createIngressController = async (
-  t: TFunction,
-  setError: SetErrorFuncType,
-
-  domain: string,
-): Promise<boolean> => {
-  // Assumption: the IngressController resource is not present - ensured at higher level
+}
 
+const createIngressController = async (t: TFunction, domain: string) => {
   const ingressController = {
     apiVersion: 'operator.openshift.io/v1',
     kind: 'IngressController',
@@ -186,71 +142,45 @@ const createIngressController = async (
 
   try {
     await k8sCreate({ model: IngressControllerModel, data: ingressController });
-    return true;
   } catch (e) {
-    // console.error('Create IngressController error: ', e);
-    setError({
-      title: t('ai:Failed to create IngressController'),
-    });
+    throw new Error(`${t('ai:Failed to create IngressController')}: ${getErrorMessage(e)}`);
   }
-
-  return false;
 };
 
-const patchProvisioningConfiguration = async ({
-  t,
-  setError,
-}: {
-  t: TFunction;
-  setError: SetErrorFuncType;
-}) => {
-  try {
-    const provisioning = await k8sGet<
-      K8sResourceCommon & { spec?: { watchAllNamespaces?: boolean } }
-    >({
-      model: ProvisioningModel,
-      name: 'provisioning-configuration',
-    });
-
-    const patches = [
-      {
-        op: provisioning.spec?.watchAllNamespaces ? 'replace' : 'add',
-        path: '/spec/watchAllNamespaces',
-        value: true,
-      },
-    ];
+export const patchProvisioning = async () => {
+  const provisioning = await k8sGet<
+    K8sResourceCommon & { spec?: { watchAllNamespaces?: boolean } }
+  >({
+    model: ProvisioningModel,
+    name: 'provisioning-configuration',
+  });
 
-    await k8sPatch({
-      model: ProvisioningModel,
-      resource: provisioning,
-      data: patches,
-    });
-  } catch (e) {
-    // console.error('Failed to patch provisioning-configuration: ', e);
-    setError({
-      title: t('ai:Failed to configure provisioning to enable registering hosts via BMC.'),
-      message: getErrorMessage(e),
-      variant: AlertVariant.warning,
-    });
+  if (provisioning.spec?.watchAllNamespaces) {
+    return;
   }
+
+  const patches = [
+    {
+      op: provisioning.spec?.watchAllNamespaces === false ? 'replace' : 'add',
+      path: '/spec/watchAllNamespaces',
+      value: true,
+    },
+  ];
+
+  await k8sPatch({
+    model: ProvisioningModel,
+    resource: provisioning,
+    data: patches,
+  });
 };
 
-const createAgentServiceConfig = async ({
+export const createAgentServiceConfig = async ({
   t,
-  setError,
-  dbVolSizeGiB,
-  fsVolSizeGiB,
-  imgVolSizeGiB,
-  ciscoIntersightURL,
+  values,
 }: {
   t: TFunction;
-  setError: SetErrorFuncType;
-
-  dbVolSizeGiB: number;
-  fsVolSizeGiB: number;
-  imgVolSizeGiB: number;
-  ciscoIntersightURL?: string;
-}): Promise<boolean> => {
+  values: CimConfigurationValues;
+}) => {
   try {
     const agentServiceConfig = {
       apiVersion: 'agent-install.openshift.io/v1beta1',
@@ -264,7 +194,7 @@ const createAgentServiceConfig = async ({
           accessModes: ['ReadWriteOnce'],
           resources: {
             requests: {
-              storage: `${dbVolSizeGiB}Gi`,
+              storage: `${values.dbVolSize}Gi`,
             },
           },
         },
@@ -272,7 +202,7 @@ const createAgentServiceConfig = async ({
           accessModes: ['ReadWriteOnce'],
           resources: {
             requests: {
-              storage: `${fsVolSizeGiB}Gi`,
+              storage: `${values.fsVolSize}Gi`,
             },
           },
         },
@@ -280,17 +210,17 @@ const createAgentServiceConfig = async ({
           accessModes: ['ReadWriteOnce'],
           resources: {
             requests: {
-              storage: `${imgVolSizeGiB}Gi`,
+              storage: `${values.imgVolSize}Gi`,
             },
           },
         },
       },
     };
 
-    if (ciscoIntersightURL) {
+    if (values.ciscoIntersightURL) {
       agentServiceConfig.metadata = {
         ...agentServiceConfig.metadata,
-        annotations: { ciscoIntersightURL },
+        annotations: { ciscoIntersightURL: values.ciscoIntersightURL },
       };
     }
 
@@ -298,99 +228,67 @@ const createAgentServiceConfig = async ({
       model: AgentServiceConfigModel,
       data: agentServiceConfig,
     });
-
-    return true;
   } catch (e) {
-    setError({
-      title: t('ai:Failed to create AgentServiceConfig'),
-      message: getErrorMessage(e),
-    });
-    return false;
+    throw new Error(`${t('ai:Failed to create AgentServiceConfig')}: ${getErrorMessage(e)}`);
   }
 };
 
-// https://access.redhat.com/documentation/en-us/red_hat_advanced_cluster_management_for_kubernetes/2.6/html/multicluster_engine/multicluster_engine_overview#enable-cim
-export const onEnableCIM = async ({
+export const editAgentServiceConfig = async ({
   t,
-  setError,
-
   agentServiceConfig,
-  platform,
-
-  dbVolSizeGiB,
-  fsVolSizeGiB,
-  imgVolSizeGiB,
-
-  configureLoadBalancer,
-  ciscoIntersightURL,
+  values,
 }: {
   t: TFunction;
-  setError: SetErrorFuncType;
-
-  agentServiceConfig?: AgentServiceConfigK8sResource;
-  platform: string;
-
-  dbVolSizeGiB: number;
-  fsVolSizeGiB: number;
-  imgVolSizeGiB: number;
-
-  configureLoadBalancer: boolean;
-  ciscoIntersightURL?: string;
+  agentServiceConfig: AgentServiceConfigK8sResource;
+  values: CimConfigurationValues;
 }) => {
-  if (['none', 'baremetal', 'openstack', 'vsphere'].includes(platform.toLocaleLowerCase())) {
-    await patchProvisioningConfiguration({ t, setError });
-  }
-
-  if (!agentServiceConfig) {
-    if (
-      !(await createAgentServiceConfig({
-        t,
-        setError,
-        dbVolSizeGiB,
-        fsVolSizeGiB,
-        imgVolSizeGiB,
-        ciscoIntersightURL,
-      }))
-    ) {
-      return false;
-    }
-  } else {
-    const patches = [] as K8sPatch;
+  const patches: Patch[] = [];
+
+  if (
+    agentServiceConfig.metadata?.annotations?.['ciscoIntersightURL'] &&
+    !values.ciscoIntersightURL
+  ) {
+    patches.push({
+      op: 'remove',
+      path: '/metadata/annotations/ciscoIntersightURL',
+    });
+  } else if (!agentServiceConfig.metadata?.annotations && values.ciscoIntersightURL) {
+    patches.push({
+      op: 'add',
+      path: '/metadata/annotations',
+      value: { ciscoIntersightURL: values.ciscoIntersightURL },
+    });
+  } else if (values.ciscoIntersightURL) {
     appendPatch(
       patches,
       '/metadata/annotations/ciscoIntersightURL',
-      ciscoIntersightURL,
+      values.ciscoIntersightURL,
       agentServiceConfig.metadata?.annotations?.['ciscoIntersightURL'],
     );
-    await k8sPatch({ model: AgentServiceConfigModel, resource: agentServiceConfig, data: patches });
   }
 
-  // see isCIMConfigProgressing()
-  window.localStorage.setItem(LOCAL_STORAGE_ID_LAST_UPDATE_TIMESTAMP, new Date().toISOString());
-
-  if (configureLoadBalancer) {
-    // Recently No to Yes only (since we do not delete the ingress controller)
-    if (await isIngressController()) {
-      return true /* Not an error */;
-    }
-
-    const assistedImageServiceRoute = await getAssistedImageServiceRoute(t, setError);
-    if (!assistedImageServiceRoute) {
-      return false;
-    }
+  if (patches.length === 0) {
+    return;
+  }
 
-    const domain = getClusterDomain(t, setError, assistedImageServiceRoute);
-    if (!domain) {
-      return false;
-    }
+  try {
+    await k8sPatch({
+      model: AgentServiceConfigModel,
+      resource: agentServiceConfig,
+      data: patches,
+    });
+  } catch (e) {
+    throw new Error(`${t('ai:Failed to save configuration')}: ${getErrorMessage(e)}`);
+  }
+};
 
-    if (
-      !(await createIngressController(t, setError, domain)) ||
-      !(await patchAssistedImageServiceRoute(t, setError, assistedImageServiceRoute, domain))
-    ) {
-      return false;
-    }
+export const configureIngressLoadBalancer = async ({ t }: { t: TFunction }) => {
+  if (await isIngressController()) {
+    return;
   }
 
-  return true;
+  const assistedImageServiceRoute = await getAssistedImageServiceRoute(t);
+  const domain = getClusterDomain(t, assistedImageServiceRoute);
+  await createIngressController(t, domain);
+  await patchAssistedImageServiceRoute(t, assistedImageServiceRoute, domain);
 };

package/lib/cim/types/k8s/agent-cluster-install.ts

@@ -56,7 +56,7 @@ export type AgentClusterInstallK8sResource = K8sResourceCommon & {
         cidr: string;
       }[];
       userManagedNetworking?: boolean;
-      networkType?: 'OpenShiftSDN' | 'OVNKubernetes';
+      networkType?: 'OpenShiftSDN' | 'OVNKubernetes' | 'CiscoACI' | 'Cilium' | 'Calico' | 'None';
     };
     holdInstallation?: boolean;
     platformType: string;

package/lib/common/components/clusterWizard/customManifests/CustomManifestsAlert.tsx

@@ -0,0 +1,39 @@
+import React from 'react';
+import { Alert, AlertVariant, Stack, StackItem } from '@patternfly/react-core';
+import { useTranslation } from '../../../hooks';
+
+export const CustomManifestsAlert = ({
+  usesExternalPlatform,
+  usesThirdPartyCNI,
+}: {
+  usesExternalPlatform: boolean;
+  usesThirdPartyCNI: boolean;
+}) => {
+  const { t } = useTranslation();
+
+  let title: string;
+  let body: string;
+
+  if (usesExternalPlatform && usesExternalPlatform) {
+    title = t("ai:You're using an external platform and a third-party CNI");
+    body = t('ai:Make sure to upload the required custom and CNI manifests in this step.');
+  } else if (usesExternalPlatform) {
+    title = t("ai:You're using an external platform");
+    body = t('ai:Make sure to upload the required custom manifests in this step.');
+  } else if (usesThirdPartyCNI) {
+    title = t("ai:You're using a third-party CNI");
+    body = t('ai:Make sure to upload the required CNI manifests in this step.');
+  } else {
+    return null;
+  }
+
+  return (
+    <Stack>
+      <StackItem>
+        <Alert variant={AlertVariant.info} isInline title={title}>
+          {body}
+        </Alert>
+      </StackItem>
+    </Stack>
+  );
+};

package/lib/common/components/clusterWizard/customManifests/index.tsx

@@ -0,0 +1 @@
+export * from './CustomManifestsAlert';

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

@@ -7,3 +7,5 @@ export { ClusterValidations, HostsValidations } from './ReviewValidations';
 export * from './clusterDetailsValidation';
 export * from './types';
 export * from './validationsInfoUtils';
+export * from './customManifests';
+export * from './networkingSteps';

package/lib/common/components/clusterWizard/networkingSteps/AvailableSubnetsControl.tsx

@@ -59,6 +59,7 @@ export interface AvailableSubnetsControlProps {
   isViewerMode?: boolean;
   hosts?: Host[];
   isMultiNodeCluster?: boolean;
+  allowSingleStackIPv6?: boolean;
 }
 
 export const AvailableSubnetsControl = ({
@@ -70,6 +71,7 @@ export const AvailableSubnetsControl = ({
   isViewerMode = false,
   hosts,
   isMultiNodeCluster = true,
+  allowSingleStackIPv6 = false,
 }: AvailableSubnetsControlProps) => {
   const { t } = useTranslation();
   const { values, errors, setFieldValue } = useFormikContext<NetworkConfigurationValues>();
@@ -207,7 +209,12 @@ export const AvailableSubnetsControl = ({
     isDualStack && values.machineNetworks && values.machineNetworks.length > 1;
 
   // Determine available subnets for primary dropdown
-  const primaryMachineSubnets = isDualStack && supportsIPv6Primary ? allSubnets : IPv4Subnets;
+  let primaryMachineSubnets: HostSubnet[];
+  if ((isDualStack && supportsIPv6Primary) || (!isDualStack && allowSingleStackIPv6)) {
+    primaryMachineSubnets = allSubnets;
+  } else {
+    primaryMachineSubnets = IPv4Subnets;
+  }
 
   // Determine available subnets for secondary dropdown
   const secondaryMachineSubnets = React.useMemo(() => {

package/lib/common/components/clusterWizard/networkingSteps/ManagedNetworkingControlGroup.tsx

@@ -55,10 +55,10 @@ export const ManagedNetworkingControlGroup = ({
             value={'userManaged'}
             label={
               <>
-                <span>{t('ai:User-Managed Networking')}</span>{' '}
+                <span>{t('ai:User-Managed networking')}</span>{' '}
                 <PopoverIcon
                   bodyContent={t(
-                    "ai:With User-Managed Networking, you'll need to provide and configure a load balancer for the API and ingress endpoints.",
+                    "ai:With User-Managed networking, you'll need to provide and configure a load balancer for the API and ingress endpoints.",
                   )}
                 />
               </>

package/lib/common/components/clusterWizard/networkingSteps/StackTypeControlGroup.tsx

@@ -10,9 +10,10 @@ import {
   NETWORK_TYPE_SDN,
 } from '../../../types';
 import { getFieldId } from '../../ui';
-import { DUAL_STACK, IPV4_STACK, NO_SUBNET_SET } from '../../../config';
+import { DUAL_STACK, NO_SUBNET_SET, SINGLE_STACK } from '../../../config';
 import { RadioField } from '../../ui/formik';
 import { ConfirmationModal, PopoverIcon } from '../../ui';
+import { useTranslation } from '../../../hooks/use-translation-wrapper';
 import { reorderNetworksByCurrentPrimary } from './reorderNetworks';
 import {
   Cluster,
@@ -36,6 +37,7 @@ export type StackTypeControlGroupProps = {
   hostSubnets: HostSubnets;
   defaultNetworkValues: StackTypeDefaultNetworkValues;
   isViewerMode?: boolean;
+  allowSingleStackIPv6?: boolean;
 };
 
 const hasDualStackConfigurationChanged = (
@@ -60,17 +62,21 @@ export const StackTypeControlGroup = ({
   hostSubnets,
   defaultNetworkValues,
   isViewerMode = false,
+  allowSingleStackIPv6 = false,
 }: StackTypeControlGroupProps) => {
+  const { t } = useTranslation();
   const { setFieldValue, values, validateForm } = useFormikContext<NetworkConfigurationValues>();
   const [openConfirmModal, setConfirmModal] = React.useState(false);
 
+  const singleStackLabel = allowSingleStackIPv6 ? t('ai:Single stack') : t('ai:IPv4');
+
   const IPv6Subnets = hostSubnets.filter((subnet) => Address6.isValid(subnet.subnet));
   const cidrIPv6 = IPv6Subnets.length >= 1 ? IPv6Subnets[0].subnet : NO_SUBNET_SET;
   const shouldSetSingleStack =
     !isViewerMode && !isDualStackSelectable && values.stackType === DUAL_STACK;
 
   const setSingleStack = React.useCallback(() => {
-    setFieldValue('stackType', IPV4_STACK);
+    setFieldValue('stackType', SINGLE_STACK);
 
     // Determine whether the first machine network is IPv4
     const firstNetwork = values.machineNetworks?.[0];
@@ -94,7 +100,8 @@ export const StackTypeControlGroup = ({
         }
       }
     }
-    // Ensure single-stack inputs are IPv4 after switching from dual-stack
+
+    // Set cluster/service to IPv4 defaults when switching to single-stack
     if (values.clusterNetworks && values.clusterNetworks.length >= 1) {
       const defaultCluster =
         defaultNetworkValues.clusterNetworksIpv4 && defaultNetworkValues.clusterNetworksIpv4[0];
@@ -196,28 +203,27 @@ export const StackTypeControlGroup = ({
       }
     }
     if (values.clusterNetworks && values.clusterNetworks?.length < 2) {
-      setFieldValue(
-        'clusterNetworks',
-        [
-          ...values.clusterNetworks,
-          defaultNetworkValues.clusterNetworksDualstack?.length
-            ? defaultNetworkValues.clusterNetworksDualstack[1]
-            : { cidr: '', hostPrefix: '', clusterId: clusterId },
-        ],
-        false,
-      );
+      const firstClusterCidr = values.clusterNetworks[0]?.cidr;
+      const isPrimaryIPv6 = firstClusterCidr && Address6.isValid(firstClusterCidr);
+      const missingFamilyNetworkDefault =
+        defaultNetworkValues.clusterNetworksDualstack?.[isPrimaryIPv6 ? 0 : 1];
+      const secondClusterNetwork = missingFamilyNetworkDefault ?? {
+        cidr: '',
+        hostPrefix: '',
+        clusterId: clusterId,
+      };
+      setFieldValue('clusterNetworks', [...values.clusterNetworks, secondClusterNetwork], false);
     }
     if (values.serviceNetworks && values.serviceNetworks?.length < 2) {
-      setFieldValue(
-        'serviceNetworks',
-        [
-          ...values.serviceNetworks,
-          defaultNetworkValues.serviceNetworksDualstack?.length
-            ? defaultNetworkValues.serviceNetworksDualstack[1]
-            : { cidr: '', clusterId: clusterId },
-        ],
-        false,
-      );
+      const firstServiceCidr = values.serviceNetworks[0]?.cidr;
+      const isPrimaryIPv6 = firstServiceCidr && Address6.isValid(firstServiceCidr);
+      const missingFamilyNetworkDefault =
+        defaultNetworkValues.serviceNetworksDualstack?.[isPrimaryIPv6 ? 0 : 1];
+      const secondServiceNetwork = missingFamilyNetworkDefault ?? {
+        cidr: '',
+        clusterId: clusterId,
+      };
+      setFieldValue('serviceNetworks', [...values.serviceNetworks, secondServiceNetwork], false);
     }
     // Initialize VIPs for dual-stack
     if (values.apiVips && values.apiVips.length < 2) {
@@ -290,14 +296,18 @@ export const StackTypeControlGroup = ({
           <SplitItem>
             <RadioField
               name={'stackType'}
-              value={IPV4_STACK}
+              value={SINGLE_STACK}
               isDisabled={!isDualStackSelectable || isViewerMode}
-              label="IPv4&nbsp;"
+              label={`${singleStackLabel}\u00A0`}
             />
           </SplitItem>
           <SplitItem>
             <PopoverIcon
-              bodyContent="Select this when your hosts are using only IPv4."
+              bodyContent={
+                allowSingleStackIPv6
+                  ? t('ai:Select a single address family (IPv4 or IPv6) for your machine network.')
+                  : t('ai:Select this when your hosts are using only IPv4.')
+              }
               buttonStyle={{ top: '-4px' }}
             />
           </SplitItem>