@openshift-assisted/ui-lib 2.52.2 → 2.53.0

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;

package/lib/common/components/clusterDetail/ClusterCredentials.tsx

@@ -1,17 +1,9 @@
 import React from 'react';
-import {
-  GridItem,
-  ClipboardCopy,
-  clipboardCopyFunc,
-  Button,
-  Alert,
-  TextInput,
-} from '@patternfly/react-core';
+import { GridItem, ClipboardCopy, clipboardCopyFunc, Alert } from '@patternfly/react-core';
 import { Credentials, Cluster } from '@openshift-assisted/types/assisted-installer-service';
 import { LoadingState, ErrorState } from '../../components/ui/uiState';
 import { DetailList, DetailItem } from '../../components/ui/DetailList';
 import { TroubleshootingOpenshiftConsoleButton } from './ConsoleModal';
-import { ExternalLinkAltIcon } from '@patternfly/react-icons/dist/js/icons/external-link-alt-icon';
 import { useTranslation } from '../../hooks/use-translation-wrapper';
 
 type ClusterCredentialsProps = {
@@ -74,55 +66,59 @@ const ClusterCredentials: React.FC<ClusterCredentialsProps> = ({
     const consoleUrl = credentials.consoleUrl
       ? getConsoleUrl(credentials.consoleUrl, isMceEnabled)
       : '';
+    const hasVips = Boolean(cluster.apiVips?.length && cluster.ingressVips?.length);
     credentialsBody = (
-      <DetailList>
-        {credentials.consoleUrl && (
-          <DetailItem
-            title={t('ai:Web Console URL')}
-            value={
-              <>
-                <Button
-                  variant="link"
-                  icon={<ExternalLinkAltIcon />}
-                  iconPosition="right"
-                  isInline
-                  onClick={() => window.open(consoleUrl, '_blank', 'noopener')}
-                  data-testid={`${idPrefix}-link-console-url`}
-                >
-                  {consoleUrl}
-                </Button>
-                <br />
-                {!!cluster.apiVips && !!cluster.ingressVips && (
-                  <TroubleshootingOpenshiftConsoleButton
-                    consoleUrl={consoleUrl}
-                    cluster={cluster}
-                    idPrefix={idPrefix}
-                  />
-                )}
-              </>
-            }
-          />
-        )}
-        {credentials.username && (
-          <>
+      <>
+        <DetailList>
+          {credentials.consoleUrl && (
             <DetailItem
-              title={t('ai:Username')}
-              value={<TextInput value={credentials.username} readOnlyVariant="default" />}
-            />
-            <DetailItem
-              title={t('ai:Password')}
+              title={t('ai:Web Console URL')}
               value={
-                <ClipboardCopy
-                  isReadOnly
-                  onCopy={(event) => clipboardCopyFunc(event, credentials.password)}
-                >
-                  &bull;&bull;&bull;&bull;&bull;
-                </ClipboardCopy>
+                <>
+                  <ClipboardCopy
+                    isReadOnly
+                    className="pf-v6-u-my-sm"
+                    data-testid={`${idPrefix}-link-console-url`}
+                  >
+                    {consoleUrl}
+                  </ClipboardCopy>
+                  {hasVips && (
+                    <TroubleshootingOpenshiftConsoleButton
+                      consoleUrl={consoleUrl}
+                      cluster={cluster}
+                      idPrefix={idPrefix}
+                    />
+                  )}
+                </>
               }
             />
-          </>
-        )}
-      </DetailList>
+          )}
+          {credentials.username && (
+            <>
+              <DetailItem
+                title={t('ai:Username')}
+                value={
+                  <ClipboardCopy isReadOnly className="pf-v6-u-my-sm">
+                    {credentials.username}
+                  </ClipboardCopy>
+                }
+              />
+              <DetailItem
+                title={t('ai:Password')}
+                value={
+                  <ClipboardCopy
+                    isReadOnly
+                    className="pf-v6-u-my-sm"
+                    onCopy={(event) => clipboardCopyFunc(event, credentials.password)}
+                  >
+                    &bull;&bull;&bull;&bull;&bull;
+                  </ClipboardCopy>
+                }
+              />
+            </>
+          )}
+        </DetailList>
+      </>
     );
   }
 

package/lib/common/components/clusterDetail/ConsoleModal.tsx

@@ -12,7 +12,6 @@ import {
 } from '@patternfly/react-core';
 import { InfoCircleIcon } from '@patternfly/react-icons/dist/js/icons/info-circle-icon';
 import { removeProtocolFromURL } from '../../api';
-import { ToolbarButton } from '../ui/Toolbar';
 import PrismCode from '../ui/PrismCode';
 import { useTranslation } from '../../hooks/use-translation-wrapper';
 import { selectApiVip, selectIngressVip } from '../../selectors';
@@ -24,11 +23,6 @@ type WebConsoleHintProps = {
   idPrefix?: string;
 };
 
-type LaunchOpenshiftConsoleButtonProps = WebConsoleHintProps & {
-  isDisabled: boolean;
-  id?: string;
-};
-
 type ConsoleModalProps = WebConsoleHintProps & {
   closeModal: () => void;
   isOpen: boolean;
@@ -103,35 +97,6 @@ export const WebConsoleHint: React.FC<WebConsoleHintProps> = ({ cluster, console
   );
 };
 
-export const LaunchOpenshiftConsoleButton: React.FC<LaunchOpenshiftConsoleButtonProps> = ({
-  cluster,
-  consoleUrl,
-  isDisabled,
-  id,
-}) => {
-  const [isOpen, setOpen] = React.useState(false);
-  const { t } = useTranslation();
-  return (
-    <>
-      <ToolbarButton
-        type="button"
-        variant={ButtonVariant.primary}
-        isDisabled={isDisabled}
-        onClick={() => setOpen(true)}
-        data-testid={id}
-      >
-        {t('ai:Launch OpenShift Console')}
-      </ToolbarButton>
-      <ConsoleModal
-        closeModal={() => setOpen(false)}
-        consoleUrl={consoleUrl}
-        cluster={cluster}
-        isOpen={isOpen}
-      />
-    </>
-  );
-};
-
 export const TroubleshootingOpenshiftConsoleButton: React.FC<WebConsoleHintProps> = ({
   cluster,
   consoleUrl,