footer.tsx

import * as React from 'react';
import {
  getDeviceSetReplica,
  getExternalStorage,
  getTotalCpu,
  getTotalMemoryInGiB,
  getRBDVolumeSnapshotClassName,
} from '@odf/core/components/utils';
import {
  ERASURE_CODING_MIN_NODES,
  MINIMUM_NODES,
  NO_PROVISIONER,
  Steps,
  StepsName,
} from '@odf/core/constants';
import { useODFNamespaceSelector } from '@odf/core/redux';
import {
  labelOCSNamespace,
  isResourceProfileAllowed,
  getDeviceSetCount,
  getNodeArchitectureFromState,
  getOsdAmount,
  isFlexibleScaling,
  isValidCapacityAutoScalingConfig,
} from '@odf/core/utils';
import { StorageClassWizardStepExtensionProps as ExternalStorage } from '@odf/odf-plugin-sdk/extensions';
import { StorageClusterKind } from '@odf/shared';
import {
  StorageAutoScalerModel,
  StorageClusterModel,
} from '@odf/shared/models';
import { getName, getNamespace } from '@odf/shared/selectors';
import { useCustomTranslation } from '@odf/shared/useCustomTranslationHook';
import { getStorageAutoScalerName, isNotFoundError } from '@odf/shared/utils';
import {
  k8sDelete,
  K8sResourceCommon,
} from '@openshift-console/dynamic-plugin-sdk';
import { TFunction } from 'react-i18next';
import { useNavigate } from 'react-router-dom-v5-compat';
import { useWizardContext, WizardFooterWrapper } from '@patternfly/react-core';
import { Button, Alert, AlertActionCloseButton } from '@patternfly/react-core';
import {
  NetworkType,
  BackingStorageType,
  DeploymentType,
  VolumeTypeValidation,
} from '../../types';
import { createClusterKmsResources } from '../kms-config/utils';
import { isIpInCidr, isValidCIDRFormat, getMonIp } from '../utils/cidr-utils';
import './create-storage-system.scss';
import {
  createNoobaaExternalPostgresResources,
  createStorageCluster,
  labelNodes,
  taintNodes,
  createOCSNamespace,
  createStorageAutoScaler,
} from './payloads';
import { WizardCommonProps, WizardState } from './reducer';

// Not to be exposed to other files to make our code name agnostic
const OCS_INTERNAL_CR_NAME = 'ocs-storagecluster';
const NOOBAA_DB_BACKUP_VOLUMESNAPSHOTCLASS =
  getRBDVolumeSnapshotClassName(OCS_INTERNAL_CR_NAME);
const validateBackingStorageStep = (
  backingStorage: WizardState['backingStorage'],
  sc: WizardState['storageClass']
) => {
  const { type, externalStorage, deployment } = backingStorage;

  switch (type) {
    case BackingStorageType.EXISTING:
      return !!sc.name && !!deployment;
    case BackingStorageType.EXTERNAL:
      return !!externalStorage;
    case BackingStorageType.LOCAL_DEVICES:
      return !!deployment;
    default:
      return false;
  }
};

const validateOptionalSettingsStep = (
  optionalSettings: WizardState['optionalSettings'],
  sc: WizardState['storageClass'],
  deployment: DeploymentType,
  type: BackingStorageType
) => {
  const {
    enableNFS,
    useExternalPostgres,
    externalPostgres,
    isDbBackup,
    dbBackup,
  } = optionalSettings;

  const {
    username,
    password,
    serverName,
    port,
    databaseName,
    tls: { enableClientSideCerts, keys },
  } = externalPostgres;

  const isMCG: boolean = deployment === DeploymentType.MCG;

  const hasPGEnabledButNoFields =
    useExternalPostgres &&
    (!username || !password || !serverName || !port || !databaseName);

  const hasClientCertsEnabledButNoKeys =
    enableClientSideCerts && (!keys.private || !keys.public);

  // The Next button is disabled only when no VolumeSnapshotClass is selected for MCG Standalone when automatic backup option enabled.
  const hasDbBackupEnabledButNoFields =
    isDbBackup && !dbBackup.volumeSnapshot?.volumeSnapshotClass && isMCG;

  switch (type) {
    case BackingStorageType.EXISTING:
      return (
        !!sc.name &&
        !!deployment &&
        !hasPGEnabledButNoFields &&
        !hasClientCertsEnabledButNoKeys &&
        !hasDbBackupEnabledButNoFields
      );
    case BackingStorageType.EXTERNAL:
      return (
        !enableNFS &&
        !hasPGEnabledButNoFields &&
        !hasClientCertsEnabledButNoKeys &&
        !hasDbBackupEnabledButNoFields
      );
    case BackingStorageType.LOCAL_DEVICES:
      return (
        !!deployment &&
        !hasPGEnabledButNoFields &&
        !hasClientCertsEnabledButNoKeys &&
        !hasDbBackupEnabledButNoFields
      );
    default:
      return false;
  }
};

const validateAdvancedSettingsStep = (
  advancedSettings: WizardState['advancedSettings'],
  type: BackingStorageType,
  nodeCount: number,
  flexibleScaling: boolean
) => {
  const {
    useErasureCoding,
    erasureCodingScheme,
    enableForcefulDeployment,
    forcefulDeploymentConfirmation,
  } = advancedSettings;

  const erasureCodingStepValid =
    !useErasureCoding ||
    !flexibleScaling ||
    (nodeCount >= ERASURE_CODING_MIN_NODES && !!erasureCodingScheme);

  // The Next button is disabled only when no VolumeSnapshotClass is selected for MCG Standalone when automatic backup option enabled.
  const hasForcefulDeploymentButNoConfirmation =
    type === BackingStorageType.LOCAL_DEVICES &&
    enableForcefulDeployment &&
    !(forcefulDeploymentConfirmation?.trim() === 'CONFIRM');

  return erasureCodingStepValid && !hasForcefulDeploymentButNoConfirmation;
};
const canJumpToNextStep = (
  name: string,
  state: WizardState,
  t: TFunction,
  supportedExternalStorage: ExternalStorage[],
  isTNFEnabled: boolean
) => {
  const {
    storageClass,
    backingStorage,
    createStorageClass,
    capacityAndNodes,
    createLocalVolumeSet,
    securityAndNetwork,
    connectionDetails,
    nodes,
    advancedSettings,
    optionalSettings,
  } = state;
  const { type, externalStorage } = backingStorage;
  const isExternal: boolean = type === BackingStorageType.EXTERNAL;
  const isRHCS: boolean = externalStorage === StorageClusterModel.kind;
  const {
    capacity,
    enableArbiter,
    pvCount,
    resourceProfile,
    volumeValidationType,
  } = capacityAndNodes;
  const isNoProvisioner = storageClass.provisioner === NO_PROVISIONER;
  const flexibleScaling = isFlexibleScaling(
    nodes,
    isNoProvisioner,
    enableArbiter
  );
  const { chartNodes, volumeSetName, isValidDiskSize, isValidDeviceType } =
    createLocalVolumeSet;
  const {
    encryption,
    kms,
    networkType,
    publicNetwork,
    clusterNetwork,
    addressRanges,
    usePublicNetwork,
    useClusterNetwork,
  } = securityAndNetwork;
  const { canGoToNextStep } =
    getExternalStorage(externalStorage, supportedExternalStorage) || {};

  const publicCidr = addressRanges?.public?.[0]?.trim() ?? '';
  const clusterCidr = addressRanges?.cluster?.[0]?.trim() ?? '';
  const hasValidNICNetwork =
    networkType === NetworkType.NIC &&
    ((usePublicNetwork && isValidCIDRFormat(publicCidr)) ||
      (useClusterNetwork && isValidCIDRFormat(clusterCidr)));

  const hasConfiguredNetwork =
    networkType === NetworkType.MULTUS
      ? !!(publicNetwork || clusterNetwork)
      : networkType === NetworkType.NIC
        ? hasValidNICNetwork
        : true;

  const hasDedicatedStorageWithCidr =
    networkType === NetworkType.NIC &&
    ((usePublicNetwork && publicCidr) || (useClusterNetwork && clusterCidr));
  /** mon-ip applies to public network (mons); cluster network CIDR does not use mon-ip checks. */
  const needsMonIpAnnotation =
    networkType === NetworkType.NIC && usePublicNetwork && !!publicCidr;
  const allNodesHaveMonIpAnnotation =
    !hasDedicatedStorageWithCidr ||
    !needsMonIpAnnotation ||
    nodes.every((node) => (getMonIp(node)?.length ?? 0) > 0);
  const allMonIpsInCidr =
    !hasDedicatedStorageWithCidr ||
    nodes.every((node) => {
      if (!usePublicNetwork || !publicCidr) return true;
      const ip = getMonIp(node);
      if (!ip) return false;
      return isIpInCidr(ip, publicCidr);
    });

  const deviceSetReplica: number = getDeviceSetReplica(
    enableArbiter,
    flexibleScaling,
    nodes
  );
  const deviceSetCount = getDeviceSetCount(pvCount, deviceSetReplica);
  const osdAmount = getOsdAmount(deviceSetCount, deviceSetReplica);

  switch (name) {
    case StepsName(t)[Steps.BackingStorage]:
      return validateBackingStorageStep(backingStorage, storageClass);
    case StepsName(t)[Steps.OptionalSettings]:
      return validateOptionalSettingsStep(
        optionalSettings,
        storageClass,
        backingStorage.deployment,
        backingStorage.type
      );
    case StepsName(t)[Steps.AdvancedSettings]:
      return validateAdvancedSettingsStep(
        advancedSettings,
        backingStorage.type,
        nodes.length,
        flexibleScaling
      );
    case StepsName(t)[Steps.CreateStorageClass]:
      return (
        !!storageClass.name &&
        canGoToNextStep &&
        canGoToNextStep(createStorageClass, storageClass.name)
      );
    case StepsName(t)[Steps.CreateLocalVolumeSet]:
      return (
        // "chartNodes.size === 0" signify no SSDs are attached, but no need to add that as it's already covered by "chartNodes.size >= MINIMUM_NODES" condition
        chartNodes.size >= MINIMUM_NODES &&
        volumeSetName.trim().length &&
        isValidDiskSize &&
        isValidDeviceType
      );
    case StepsName(t)[Steps.CapacityAndNodes]: {
      const architecture = getNodeArchitectureFromState(nodes);
      if (isTNFEnabled) {
        return nodes.length === 2;
      } else {
        return (
          nodes.length >= MINIMUM_NODES &&
          capacity &&
          ![VolumeTypeValidation.UNKNOWN, VolumeTypeValidation.ERROR].includes(
            volumeValidationType
          ) &&
          isResourceProfileAllowed(
            resourceProfile,
            getTotalCpu(nodes),
            getTotalMemoryInGiB(nodes),
            osdAmount,
            architecture,
            optionalSettings.enableNFS
          ) &&
          isValidCapacityAutoScalingConfig(
            capacityAndNodes.capacityAutoScaling.enable,
            capacityAndNodes.capacityAutoScaling.capacityLimit
          )
        );
      }
    }
    case StepsName(t)[Steps.SecurityAndNetwork]:
      if (isExternal && isRHCS) {
        return canGoToNextStep(connectionDetails, storageClass.name);
      }
      return (
        encryption.hasHandled &&
        kms.providerState.hasHandled &&
        hasConfiguredNetwork &&
        allNodesHaveMonIpAnnotation &&
        allMonIpsInCidr
      );
    case StepsName(t)[Steps.Security]:
      return encryption.hasHandled && kms.providerState.hasHandled;
    case StepsName(t)[Steps.ReviewAndCreate]:
      return true;
    default:
      return false;
  }
};

const handleReviewAndCreateNext = async (
  state: WizardState,
  handleError: (err: string, showError: boolean) => void,
  navigate,
  odfNamespace: string,
  existingNamespaces: K8sResourceCommon[],
  isTNFEnabled: boolean
) => {
  const { nodes, capacityAndNodes } = state;
  const { systemNamespace, deployment, type } = state.backingStorage;
  const { useExternalPostgres, externalPostgres } = state.optionalSettings;
  const { encryption, kms } = state.securityAndNetwork;
  const isMCG: boolean = deployment === DeploymentType.MCG;
  const nsAlreadyExists = !!existingNamespaces.find(
    (ns) => getName(ns) === systemNamespace
  );

  const createNooBaaResources = async () => {
    if (useExternalPostgres) {
      let keyTexts = { private: '', public: '' };
      if (externalPostgres.tls.enableClientSideCerts) {
        const keys = externalPostgres.tls.keys;
        const privateKey = await keys.private.text();
        const publicKey = await keys.public.text();
        keyTexts = { private: privateKey, public: publicKey };
      }
      await Promise.all(
        createNoobaaExternalPostgresResources(
          systemNamespace,
          externalPostgres,
          keyTexts
        )
      );
    }
  };

  const createAdditionalFeatureResources = async () => {
    if (capacityAndNodes.enableTaint && !isMCG) await taintNodes(nodes);

    /**
     * CSI KMS ConfigMap and Secrets always needs to be created in ODF install namespace (that is, where Rook is deployed),
     * whereas OCS KMS ConfigMap and Secrets needs to be created in the namespace where Ceph is being deployed (StorageSystem namespace).
     * ToDo: External mode do not support KMS and only single Internal mode is allowed, so it should work for now,
     * but in future, if need arises, first check whether CSI ConfigMap already exists or not before creating KMS related resources for multiple clusters.
     * Also, change name of "ceph-csi-kms-token" token Secret (if need to create multiple in Rook namespace).
     */
    if (encryption.advanced)
      // as currently only one internal cluster is allowed, "systemNamespace" (where intenal cluster is being created) and "odfNamespace" (where ODF is installed) will be same
      await Promise.all(
        createClusterKmsResources(
          kms.providerState,
          systemNamespace,
          odfNamespace,
          kms.provider,
          isMCG
        )
      );

    if (!isTNFEnabled) await createNooBaaResources();
  };

  try {
    systemNamespace === odfNamespace || nsAlreadyExists
      ? await labelOCSNamespace(systemNamespace)
      : await createOCSNamespace(systemNamespace);

    let storageCluster: StorageClusterKind;
    if (isMCG) {
      await createAdditionalFeatureResources();
      storageCluster = await createStorageCluster(
        state,
        systemNamespace,
        OCS_INTERNAL_CR_NAME,
        isTNFEnabled
      );
    } else if (
      type === BackingStorageType.EXISTING ||
      type === BackingStorageType.LOCAL_DEVICES
    ) {
      await labelNodes(nodes, systemNamespace);
      await createAdditionalFeatureResources();
      storageCluster = await createStorageCluster(
        state,
        systemNamespace,
        OCS_INTERNAL_CR_NAME,
        isTNFEnabled
      );
    }
    if (storageCluster) {
      try {
        // Delete preexisting ui-created autoscaler to avoid a misconfiguration.
        await k8sDelete({
          model: StorageAutoScalerModel,
          resource: {
            metadata: {
              name: getStorageAutoScalerName(storageCluster),
              namespace: getNamespace(storageCluster),
            },
          },
        });
      } catch (error) {
        // It's OK if it didn't exist.
        if (!isNotFoundError(error)) {
          // eslint-disable-next-line no-console
          console.error(
            `Error while deleting preexisting capacity autoscaling: ${error.message}`
          );
        }
      }
      if (state.capacityAndNodes.capacityAutoScaling.enable) {
        // Don't stop the workflow on autoscaler creation error.
        try {
          await createStorageAutoScaler(
            state.capacityAndNodes.capacityAutoScaling.capacityLimit,
            storageCluster
          );
        } catch (error) {
          // TODO: raise a notification once the notification system is implemented.
          // eslint-disable-next-line no-console
          console.error(
            `Error while enabling capacity autoscaling: ${error.message}`
          );
        }
      }
    }
    navigate('/odf/storage-cluster');
  } catch (err) {
    handleError(err.message, true);
  }
};

export const CreateStorageSystemFooter: React.FC<
  CreateStorageSystemFooterProps
> = ({
  dispatch,
  state,
  disableNext,
  supportedExternalStorage,
  existingNamespaces,
  isTNFEnabled,
}) => {
  const { t } = useCustomTranslation();
  const navigate = useNavigate();
  const { activeStep, goToNextStep, goToPrevStep } = useWizardContext();

  const { odfNamespace, isNsSafe } = useODFNamespaceSelector();

  const [requestInProgress, setRequestInProgress] = React.useState(false);
  const [requestError, setRequestError] = React.useState('');
  const [showErrorAlert, setShowErrorAlert] = React.useState(false);

  const stepName = activeStep.name as string;
  const { deployment } = state.backingStorage;
  const { isDbBackup } = state.optionalSettings;
  const isMCG: boolean = deployment === DeploymentType.MCG;

  const jumpToNextStep = canJumpToNextStep(
    stepName,
    state,
    t,
    supportedExternalStorage,
    isTNFEnabled
  );

  const moveToNextStep = () => {
    goToNextStep();
  };

  const handleError = (errorMessage: string, showError: boolean) => {
    setRequestError(errorMessage);
    setShowErrorAlert(showError);
  };

  const handleNext = async () => {
    switch (stepName) {
      case StepsName(t)[Steps.CreateLocalVolumeSet]:
        dispatch({
          type: 'wizard/setCreateLocalVolumeSet',
          payload: { field: 'showConfirmModal', value: true },
        });
        break;
      case StepsName(t)[Steps.OptionalSettings]:
        // Auto-select the RBD VolumeSnapshotClass for internal mode when automatic backup is enabled.
        if (isDbBackup && !isMCG) {
          dispatch({
            type: 'optionalSettings/dbBackup/volumeSnapshot/volumeSnapshotClass',
            payload: NOOBAA_DB_BACKUP_VOLUMESNAPSHOTCLASS,
          });
        }
        moveToNextStep();
        break;
      case StepsName(t)[Steps.ReviewAndCreate]:
        setRequestInProgress(true);
        await handleReviewAndCreateNext(
          state,
          handleError,
          navigate,
          odfNamespace,
          existingNamespaces,
          isTNFEnabled
        );
        setRequestInProgress(false);
        break;
      default:
        moveToNextStep();
    }
  };

  return (
    <>
      {showErrorAlert && (
        <Alert
          className="odf-create-storage-system-footer__alert"
          variant="danger"
          isInline
          actionClose={
            <AlertActionCloseButton onClose={() => handleError('', false)} />
          }
          title={t('An error has occurred')}
        >
          {requestError}
        </Alert>
      )}
      <WizardFooterWrapper>
        <Button
          isLoading={requestInProgress || null}
          isDisabled={
            disableNext || requestInProgress || !jumpToNextStep || !isNsSafe
          }
          variant="primary"
          onClick={handleNext}
          className="pf-v6-u-mr-sm"
        >
          {stepName === StepsName(t)[Steps.ReviewAndCreate]
            ? t('Create storage system')
            : t('Next')}
        </Button>
        {/* Disabling the back button for the first step (Backing storage) in wizard */}
        <Button
          variant="secondary"
          onClick={goToPrevStep}
          isDisabled={
            stepName === StepsName(t)[Steps.BackingStorage] ||
            requestInProgress ||
            !isNsSafe
          }
          className="pf-v6-u-mr-sm"
        >
          {t('Back')}
        </Button>
        <Button
          variant="secondary"
          onClick={() => navigate(-1)}
          isDisabled={requestInProgress}
        >
          {t('Cancel')}
        </Button>
      </WizardFooterWrapper>
    </>
  );
};

type CreateStorageSystemFooterProps = WizardCommonProps & {
  disableNext: boolean;
  hasOCS: boolean;
  supportedExternalStorage: ExternalStorage[];
  existingNamespaces: K8sResourceCommon[];
  isTNFEnabled: boolean;
};