@openshift-assisted/ui-lib 2.52.1 → 2.53.0

package/lib/cim/components/helpers/versions.ts

@@ -7,44 +7,52 @@ import {
   OsImage,
 } from '../../types';
 import { CpuArchitecture, OpenshiftVersionOptionType } from '../../../common';
-import { OpenshiftVersion } from '@openshift-assisted/types/assisted-installer-service';
 import { getComparableVersionInt } from '../../../common/utils';
 
-export const getVersionFromReleaseImage = (releaseImage = '') => {
-  const match = /.+:(\d+\.\d+(?:\.\d+)?(?:-\w+)?)/gm.exec(releaseImage);
+export const getVersionFromReleaseString = (value = '') => {
+  const match = /(\d+\.\d+(?:\.\d+)?(?:-\w+)?)/gm.exec(value);
   if (match && match.length > 1 && match[1]) {
     return match[1];
   }
 };
 
-const getCPUArchFromReleaseImage = (releaseImage = '') => {
-  const match = /.+:.*-(.*)/gm.exec(releaseImage);
+export const getVersionFromClusterImageSet = (clusterImageSet?: ClusterImageSetK8sResource) => {
+  return (
+    getVersionFromReleaseString(clusterImageSet?.metadata?.labels?.['releaseTag']) ||
+    getVersionFromReleaseString(clusterImageSet?.spec?.releaseImage) ||
+    clusterImageSet?.metadata?.name ||
+    ''
+  );
+};
+
+const getCPUArchFromReleaseString = (value = '') => {
+  const match = /(?:\d+\.)+\d+-(x86-64|[\w_]+)/gm.exec(value);
   if (match && match.length > 1 && match[1]) {
     return match[1];
   }
 };
 
-// eslint-disable-next-line
-const getSupportLevelFromChannel = (
-  channel?: string,
-): OpenshiftVersion['supportLevel'] | 'custom' => {
-  if (!channel) {
-    return 'maintenance';
-  }
-
-  if (channel.startsWith('fast')) {
-    return 'beta'; // TODO(mlibra): Is this correct?
-  }
+const getCPUArchFromClusterImageSet = (clusterImageSet?: ClusterImageSetK8sResource) => {
+  const cpuArch =
+    clusterImageSet?.metadata?.labels?.architecture ||
+    getCPUArchFromReleaseString(clusterImageSet?.metadata?.labels?.['releaseTag']) ||
+    getCPUArchFromReleaseString(clusterImageSet?.spec?.releaseImage) ||
+    getCPUArchFromReleaseString(clusterImageSet?.metadata?.name) ||
+    '';
 
-  if (channel.startsWith('stable')) {
-    return 'production';
+  switch (cpuArch) {
+    case CpuArchitecture.x86:
+    case CpuArchitecture.ARM:
+    case CpuArchitecture.s390x:
+    case CpuArchitecture.MULTI:
+      return cpuArch as CpuArchitecture;
+    case 'x86-64':
+      return CpuArchitecture.x86;
+    default:
+      return undefined;
   }
-
-  return 'beta';
 };
 
-export const supportedNutanixPlatforms = ['x86_64', 'x86-64'];
-
 export const isValidImageSet = (
   cis: ClusterImageSetK8sResource,
   architectures?: string[],
@@ -71,20 +79,16 @@ const extractMajorMinor = (version: string): string => {
 const toVersionOption = (
   clusterImageSet: ClusterImageSetK8sResource,
 ): OpenshiftVersionOptionType => {
-  const version =
-    getVersionFromReleaseImage(clusterImageSet.spec?.releaseImage) ||
-    clusterImageSet.metadata?.name ||
-    '';
-  const cpuArch = getCPUArchFromReleaseImage(clusterImageSet.spec?.releaseImage);
+  const version = getVersionFromClusterImageSet(clusterImageSet);
+  const cpuArch = getCPUArchFromClusterImageSet(clusterImageSet);
+
   return {
     label: `OpenShift ${version}`,
     version,
     value: clusterImageSet.metadata?.name as string,
     default: false,
-    // (rawagner) ACM does not have the warning so changing to 'production'
-    // supportLevel : getSupportLevelFromChannel(clusterImageSet.metadata?.labels?.channel)
-    supportLevel: 'production',
-    cpuArchitectures: cpuArch ? [cpuArch as CpuArchitecture] : undefined,
+    supportLevel: 'production', // ACM doesn't have feature support levels
+    cpuArchitectures: cpuArch ? [cpuArch] : undefined,
   };
 };
 
@@ -101,6 +105,8 @@ const hasMatchingOsImage = (
   return osImageVersions.includes(extractMajorMinor(version.version));
 };
 
+const supportedNutanixPlatforms = ['x86_64', 'x86-64'];
+
 export const getOCPVersions = (
   clusterImageSets: ClusterImageSetK8sResource[],
   isNutanix?: boolean,

package/lib/cim/components/modals/CimConfiguration/CimConfigurationModal.tsx

@@ -20,12 +20,18 @@ import parseUrl from 'parse-url';
 import { useTranslation } from '../../../../common/hooks/use-translation-wrapper';
 import { getStorageSizeGiB } from '../../helpers';
 import { AlertPayload } from '../../../../common';
+import { getErrorMessage } from '../../../../common/utils';
 
 import { CimConfigurationModalProps, CimConfigurationValues } from './types';
-import { onEnableCIM } from './persist';
+import {
+  patchProvisioning,
+  createAgentServiceConfig,
+  editAgentServiceConfig,
+  configureIngressLoadBalancer,
+} from './persist';
 import { CimConfigDisconnectedAlert } from './CimConfigDisconnectedAlert';
 import { MIN_DB_VOL_SIZE, MIN_FS_VOL_SIZE, MIN_IMG_VOL_SIZE } from './constants';
-import { isCIMConfigProgressing } from './utils';
+import { isCIMConfigProgressing, LOCAL_STORAGE_ID_LAST_UPDATE_TIMESTAMP } from './utils';
 import { resetCimConfigProgressAlertSuccessStatus } from './CimConfigProgressAlert';
 import { CimConfigurationFormFields } from './CimConfigurationFormFields';
 
@@ -52,24 +58,45 @@ export const CimConfigurationModal: React.FC<CimConfigurationModalProps> = ({
     helpers.setSubmitting(true);
     resetCimConfigProgressAlertSuccessStatus();
 
-    if (
-      await onEnableCIM({
-        t,
-        setError,
-        agentServiceConfig,
-        platform,
-        dbVolSizeGiB: values.dbVolSize,
-        fsVolSizeGiB: values.fsVolSize,
-        imgVolSizeGiB: values.imgVolSize,
-        configureLoadBalancer: values.configureLoadBalancer,
-        ciscoIntersightURL: values.addCiscoIntersightURL ? values.ciscoIntersightURL : undefined,
-      })
-    ) {
-      // successfully persisted
+    try {
+      if (['none', 'baremetal', 'openstack', 'vsphere'].includes(platform.toLocaleLowerCase())) {
+        try {
+          await patchProvisioning();
+        } catch (e) {
+          setError({
+            title: t('ai:Failed to configure provisioning to enable registering hosts via BMC.'),
+            message: getErrorMessage(e),
+            variant: AlertVariant.warning,
+          });
+          setConfigureLoadBalancerInitial(values.configureLoadBalancer);
+          return;
+        }
+      }
+
+      if (isEdit && agentServiceConfig) {
+        await editAgentServiceConfig({
+          t,
+          agentServiceConfig,
+          values,
+        });
+      } else {
+        await createAgentServiceConfig({ t, values });
+      }
+
+      window.localStorage.setItem(LOCAL_STORAGE_ID_LAST_UPDATE_TIMESTAMP, new Date().toISOString());
+
+      if (values.configureLoadBalancer) {
+        await configureIngressLoadBalancer({ t });
+      }
+
       onClose();
-    } else {
-      // keep modal open and show error
+    } catch (err) {
+      setError({
+        title: t('ai:Failed to save configuration'),
+        message: getErrorMessage(err),
+      });
       setConfigureLoadBalancerInitial(values.configureLoadBalancer);
+    } finally {
       helpers.setSubmitting(false);
     }
   };

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/hooks/index.tsx

@@ -1,3 +1,4 @@
 export * from './useConfigMaps';
 export * from './useAgentServiceConfig';
 export * from './useEvents';
+export * from './useAgents';

package/lib/cim/hooks/useAgents.tsx

@@ -0,0 +1,15 @@
+import { useK8sWatchResource } from './useK8sWatchResource';
+import { AgentK8sResource } from '../types';
+import { K8sWatchHookProps } from './types';
+
+export const useAgents = (props: K8sWatchHookProps) =>
+  useK8sWatchResource<AgentK8sResource[]>(
+    {
+      groupVersionKind: {
+        group: 'agent-install.openshift.io',
+        kind: 'Agent',
+        version: 'v1beta1',
+      },
+    },
+    props,
+  );

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;