@openshift-assisted/ui-lib 2.8.3-cim → 2.9.5-cim

package/lib/common/components/ui/formik/validationSchemas.test.ts

@@ -0,0 +1,368 @@
+import { test, describe, expect } from 'vitest';
+import {
+  baseDomainValidationSchema,
+  dnsNameValidationSchema,
+  hostPrefixValidationSchema,
+  ipBlockValidationSchema,
+  ipValidationSchema,
+  macAddressValidationSchema,
+  nameValidationSchema,
+  noProxyValidationSchema,
+  pullSecretValidationSchema,
+} from './validationSchemas';
+import { TFunction } from 'react-i18next';
+import { CLUSTER_NAME_MAX_LENGTH } from './constants';
+
+const t: TFunction = (t: string) => t;
+
+describe('validationSchemas', () => {
+  test('noProxyValidationSchema accepts input', async () => {
+    const valid = [
+      '.x.com',
+      '.x.com,.y.org, .z.net   , u.foo.bar',
+      '.svc',
+      'localhost',
+      '9999',
+      '.9999',
+      'kraken',
+      'a-x.com',
+      '.x.com,',
+    ];
+
+    await Promise.all(
+      valid.map((value) =>
+        noProxyValidationSchema
+          .validate(value)
+          .catch(() => expect(value).toBe('was rejected but is valid')),
+      ),
+    );
+  });
+
+  test('noProxyValidationSchema rejects input', async () => {
+    const invalid = ['.x.com.', '.x.com,.y.org., .z.net', '-x.com'];
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        noProxyValidationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+
+  test('nameValidationSchema for clusters', async () => {
+    const usedClusterNames = ['cluster-one', 'cluster-two'];
+    const valid = [
+      'cluster-one-foo',
+      'cluster',
+      'aa',
+      'a9',
+      '0a',
+      'a'.repeat(CLUSTER_NAME_MAX_LENGTH),
+    ];
+    const invalid = [
+      'cluster$',
+      'cluster-',
+      's',
+      '-a',
+      'x.y',
+      'a@',
+      'a%',
+      'b'.repeat(CLUSTER_NAME_MAX_LENGTH + 1),
+      ...usedClusterNames,
+    ];
+
+    const validationSchema = nameValidationSchema(t, usedClusterNames, '', true, false);
+
+    await Promise.all(
+      valid.map((value) =>
+        validationSchema
+          .validate(value)
+          .catch((msg: string) => expect(value).toBe(`was rejected but is valid: ${msg}`)),
+      ),
+    );
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        validationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+
+  test('pullSecretValidationSchema', async () => {
+    const valid = ['', '{"auths": {}}'];
+    const invalid = ['{}', '{"foo":"bar"}', '"auths":"{}"', '{"auths": "foo"}'];
+
+    await Promise.all(
+      valid.map((value) =>
+        pullSecretValidationSchema
+          .validate(value)
+          .catch((msg: string) => expect(value).toBe(`was rejected but is valid: ${msg}`)),
+      ),
+    );
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        pullSecretValidationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+
+  test('ipValidationSchema', async () => {
+    const valid = [
+      '1.1.1.1',
+      '0.0.0.0',
+      '255.255.255.255',
+      '2345:0425:2CA1:0000:0000:0567:5673:23b5',
+      '2345:0425:2CA1:0::0567:5673:23b5',
+      '::',
+    ];
+    const invalid = [
+      '',
+      '1.1.1.1.',
+      '1.1.1',
+      '1.1.1.',
+      '255.255.255.256',
+      '1.1.1.a',
+      '1.1.1.*',
+      '2345:0425:2CA1:0:0:0567:5673:',
+    ];
+
+    await Promise.all(
+      valid.map((value) =>
+        ipValidationSchema
+          .validate(value)
+          .catch((msg: string) => expect(value).toBe(`was rejected but is valid: ${msg}`)),
+      ),
+    );
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        ipValidationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+
+  test('macAddressValidationSchema', async () => {
+    const valid = ['', '00:00:0A:BB:28:FC', '00:00:0A:BB:28:fc'];
+    const invalid = [
+      ':00:0A:BB:28:FC',
+      '0:00:0A:BB:28:FC',
+      '00:00:0A:BB:28:FG',
+      '00:00:0A:BB:28:Fg',
+      '00:00:0A:BB:28:',
+      '00000ABB28FC',
+      '00:00:0A:BB:28',
+      '00:00:0A:BB:28 FC',
+      '00:00:0A:BB:28-FC',
+    ];
+
+    await Promise.all(
+      valid.map((value) =>
+        macAddressValidationSchema
+          .validate(value)
+          .catch((msg: string) => expect(value).toBe(`was rejected but is valid: ${msg}`)),
+      ),
+    );
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        macAddressValidationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+
+  test('ipBlockValidationSchema', async () => {
+    const valid = ['192.1.1.0/24', '192.1.0.0/16', '193.0.0.0/8'];
+    const invalid = [
+      '',
+      '192.168.1.0',
+      '192.168.1.0/24',
+      '192.1.1.0/16',
+      '192.0.0.0/8' /* Overlap */,
+    ];
+
+    const validationSchema = ipBlockValidationSchema(['192.168.1.0']);
+    await Promise.all(
+      valid.map((value) =>
+        validationSchema
+          .validate(value)
+          .catch((msg: string) => expect(value).toBe(`was rejected but is valid: ${msg}`)),
+      ),
+    );
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        validationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+
+  test('dnsNameValidationSchema', async () => {
+    const valid = ['', 'aa.com', 'aa.com.com.com.com', 'aa.com.' + 'b'.repeat(63)];
+    const invalid = [
+      '00:00:0A:BB:28:FC',
+      '192.1.1.1',
+      '.aa.com',
+      'aa.com.',
+      'a',
+      'aa',
+      'aa,com',
+      'aa.com.' + 'b'.repeat(63 + 1),
+      'aa.com/bb',
+    ];
+
+    await Promise.all(
+      valid.map((value) =>
+        dnsNameValidationSchema
+          .validate(value)
+          .catch((msg: string) => expect(value).toBe(`was rejected but is valid: ${msg}`)),
+      ),
+    );
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        dnsNameValidationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+
+  test('hostPrefixValidationSchema for IPv4', async () => {
+    const valid = [16, 25];
+    const invalid = ['', 'a', 0, 1, 33, 15, 26];
+
+    const validationSchema = hostPrefixValidationSchema('192.168.0.0/16');
+    await Promise.all(
+      valid.map((value) =>
+        validationSchema
+          .validate(value)
+          .catch((msg: string) => expect(value).toBe(`was rejected but is valid: ${msg}`)),
+      ),
+    );
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        validationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+
+  test('hostPrefixValidationSchema for IPv6', async () => {
+    const valid = [8, 32, 128];
+    const invalid = ['', 'a', 0, 1, 7, 129];
+
+    const validationSchema = hostPrefixValidationSchema('2002::1234:abcd:ffff:c0a8:101/64');
+    await Promise.all(
+      valid.map((value) =>
+        validationSchema
+          .validate(value)
+          .catch((msg: string) => expect(value).toBe(`was rejected but is valid: ${msg}`)),
+      ),
+    );
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        validationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+
+  test('baseDomainNameValidationSchema', async () => {
+    const valid = [
+      'a.com',
+      'co',
+      '1c',
+      '1-c',
+      '1--c',
+      'aaa',
+      'abc.def',
+      'a-aa.com',
+      'a--aa.com',
+      'aa.com.com.com.com',
+      'red.cat--rahul.com',
+    ];
+    const invalid = [
+      'a',
+      '-',
+      'a-',
+      '-aaa.com.',
+      'aaa-.com',
+      'a.c',
+      'aaa.c',
+      'DNSnamescancontainonlyalphabeticalcharactersa-znumericcharacters0-9theminussign-andtheperiod',
+      'DNSnamescancontainonlyalphabeticalcharactersa-znumericcharacters0-9theminussign-andtheperiod.com',
+    ];
+
+    await Promise.all(
+      valid.map((value) =>
+        baseDomainValidationSchema
+          .validate(value)
+          .catch(() => expect(value).toBe(`was rejected but is valid`)),
+      ),
+    );
+
+    let counter = 0;
+    await Promise.all(
+      invalid.map((value) =>
+        baseDomainValidationSchema.validate(value).then(
+          () => expect(value).toBe('should be rejected since it is invalid'),
+          () => counter++,
+        ),
+      ),
+    );
+
+    expect(counter).toBe(invalid.length);
+  });
+});

package/lib/common/components/ui/formik/validationSchemas.ts

@@ -5,7 +5,13 @@ import { isInSubnet } from 'is-in-subnet';
 import * as Yup from 'yup';
 
 import { TFunction } from 'i18next';
-import { ClusterNetwork, MachineNetwork, ServiceNetwork } from '../../../api/types';
+import {
+  ApiVip,
+  ClusterNetwork,
+  IngressVip,
+  MachineNetwork,
+  ServiceNetwork,
+} from '@openshift-assisted/types/assisted-installer-service';
 import { NO_SUBNET_SET } from '../../../config/constants';
 import { ProxyFieldsType } from '../../../types';
 import { HostSubnets, NetworkConfigurationValues } from '../../../types/clusters';
@@ -21,6 +27,8 @@ import {
   nameValidationMessages,
 } from './constants';
 import { allSubnetsIPv4, getAddress, trimCommaSeparatedList, trimSshPublicKey } from './utils';
+import { selectApiVip, selectIngressVip } from '../../../selectors';
+import { head } from 'lodash-es';
 
 const ALPHANUMERIC_REGEX = /^[a-zA-Z0-9]+$/;
 const NAME_START_END_REGEX = /^[a-z0-9](.*[a-z0-9])?$/;
@@ -30,11 +38,11 @@ const CLUSTER_NAME_VALID_CHARS_REGEX = /^[a-z0-9-]*$/;
 const SSH_PUBLIC_KEY_REGEX =
   /^(ssh-rsa|ssh-ed25519|ecdsa-[-a-z0-9]*) AAAA[0-9A-Za-z+/]+[=]{0,3}( .+)?$/;
 const DNS_NAME_REGEX = /^([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}$/;
-const BASE_DOMAIN_REGEX = /^([a-z0-9]+(-[a-z0-9]+)*)$/;
-const DNS_NAME_REGEX_OCM = /^([a-z0-9]+(-[a-z0-9]+)*[.])+[a-z]{2,}$/;
+const BASE_DOMAIN_REGEX = /^[a-z\d][\-]*[a-z\d]+$/;
+const DNS_NAME_REGEX_OCM = /^([a-z\d]([\-]*[a-z\d]+)*\.)+[a-z\d]+[\-]*[a-z\d]+$/;
 
 const PROXY_DNS_REGEX =
-  /(^\.?([a-zA-Z0-9_]{1}[a-zA-Z0-9_-]{0,62}){1}(\.[a-zA-Z0-9_]{1}[a-zA-Z0-9_-]{0,62})+$)/;
+  /(^\.?([a-zA-Z0-9_]{1}[a-zA-Z0-9_-]{0,62}){1}(\.[a-zA-Z0-9_]{1}[a-zA-Z0-9_-]{0,62})*$)/;
 const IP_V4_ZERO = '0.0.0.0';
 const IP_V6_ZERO = '0000:0000:0000:0000:0000:0000:0000:0000';
 const MAC_REGEX = /^([0-9A-Fa-f]{2}[:]){5}([0-9A-Fa-f]{2})$/;
@@ -220,15 +228,15 @@ export const vipRangeValidationSchema = (
     },
   );
 
-const vipUniqueValidationSchema = ({ ingressVip, apiVip }: NetworkConfigurationValues) =>
+const vipUniqueValidationSchema = ({ ingressVips, apiVips }: NetworkConfigurationValues) =>
   Yup.string().test(
     'vip-uniqueness-validation',
     'The Ingress and API IP addresses cannot be the same.',
     (value) => {
-      if (!value) {
+      if (!value || ingressVips?.length === 0 || apiVips?.length === 0) {
         return true;
       }
-      return ingressVip !== apiVip;
+      return selectApiVip({ apiVips }) !== selectIngressVip({ ingressVips });
     },
   );
 
@@ -280,12 +288,12 @@ export const vipValidationSchema = (
 export const vipNoSuffixValidationSchema = (
   hostSubnets: HostSubnets,
   values: NetworkConfigurationValues,
-  initialValue?: string,
+  initialValues?: ApiVip[] | IngressVip[],
 ) =>
   Yup.mixed().when(['vipDhcpAllocation', 'managedNetworkingType'], {
     is: (vipDhcpAllocation, managedNetworkingType) =>
       !vipDhcpAllocation && managedNetworkingType !== 'userManaged',
-    then: requiredOnceSet(initialValue, 'Required. Please provide an IP address')
+    then: requiredOnceSet(head(initialValues)?.ip, 'Required. Please provide an IP address')
       .concat(ipNoSuffixValidationSchema)
       .concat(vipRangeValidationSchema(hostSubnets, values, false))
       .concat(vipBroadcastValidationSchema(values))
@@ -296,6 +304,25 @@ export const vipNoSuffixValidationSchema = (
       }),
   });
 
+export const vipArrayValidationSchema = <T>(
+  hostSubnets: HostSubnets,
+  values: NetworkConfigurationValues,
+  initialValues?: ApiVip[] | IngressVip[],
+) =>
+  (values.apiVips?.length && values.managedNetworkingType === 'clusterManaged'
+    ? Yup.array<T>().of(
+        Yup.object().shape({
+          clusterId: Yup.string(),
+          ip: vipNoSuffixValidationSchema(hostSubnets, values, initialValues),
+        }),
+      )
+    : Yup.array<T>()
+  ).test(
+    'vips-length',
+    'Both API and ingress APIs must be provided.',
+    (_value) => values.apiVips?.length === values.ingressVips?.length,
+  );
+
 export const ipBlockValidationSchema = (reservedCidrs: string | string[] | undefined) =>
   Yup.string()
     .required('A value is required.')
@@ -371,9 +398,10 @@ export const dnsNameValidationSchema = Yup.string()
   });
 
 export const validateBaseDomainName = (baseDomainName: string) => {
-  if (baseDomainName.match(BASE_DOMAIN_REGEX)) return true;
-  else if (baseDomainName.match(DNS_NAME_REGEX_OCM)) return true;
-  else return false;
+  if (baseDomainName.match(BASE_DOMAIN_REGEX) && baseDomainName.length > 1) {
+    return true;
+  }
+  return !!baseDomainName.match(DNS_NAME_REGEX_OCM);
 };
 
 export const baseDomainValidationSchema = Yup.string()

package/lib/common/config/constants.ts

@@ -1,17 +1,31 @@
 import { TFunction } from 'i18next';
 import { ValidationsInfo, HostRole } from '../types/hosts';
-import { Cluster, ClusterValidationId, DiskRole, Event, HostValidationId } from '../api';
+import {
+  Cluster,
+  ClusterValidationId,
+  DiskRole,
+  Event,
+  HostValidationId,
+} from '@openshift-assisted/types/assisted-installer-service';
 import { ValidationGroup as ClusterValidationGroup } from '../types/clusters';
 import { FeatureSupportLevelData } from '../components/featureSupportLevels/FeatureSupportLevelContext';
-import { NewFeatureSupportLevelData } from '../components/newFeatureSupportLevels';
+import type { NewFeatureSupportLevelData } from '../components/newFeatureSupportLevels';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/ban-ts-comment
 // @ts-ignore
-import buildManifest from '../../../build/build.json'; // This file is generated at build-time.
+import buildManifest from '@openshift-assisted/ui-lib/package.json'; // This file is generated at build-time.
+
+export const getShortOpenshiftVersion = (ocpVersion?: string) =>
+  ocpVersion?.split('.').slice(0, 2).join('.');
+
+export const ASSISTED_INSTALLER_DOCUMENTATION_LINK =
+  'https://access.redhat.com/documentation/en-us/assisted_installer_for_openshift_container_platform/2022/html/assisted_installer_for_openshift_container_platform/index';
 
 export const OPENSHIFT_LIFE_CYCLE_DATES_LINK =
   'https://access.redhat.com/support/policy/updates/openshift#dates';
-export const getOpenShiftNetworkingDocsLink = (ocpVersion = '4.7') =>
-  `https://docs.openshift.com/container-platform/${ocpVersion}/installing/installing_bare_metal/installing-bare-metal.html#installation-network-user-infra_installing-bare-metal`;
+export const getOpenShiftNetworkingDocsLink = (ocpVersion?: string) =>
+  `https://docs.openshift.com/container-platform/${
+    getShortOpenshiftVersion(ocpVersion) || '4.13'
+  }/installing/installing_bare_metal/installing-bare-metal.html#installation-network-user-infra_installing-bare-metal`;
 export const CLUSTER_MANAGER_SITE_LINK = 'https://console.redhat.com/openshift/install/pull-secret';
 export const PULL_SECRET_INFO_LINK = CLUSTER_MANAGER_SITE_LINK;
 export const ODF_REQUIREMENTS_LINK =
@@ -96,8 +110,8 @@ export const clusterFieldLabels = (t: TFunction): { [key in string]: string } =>
   clusterNetworkCidr: t('ai:Cluster network CIDR'),
   clusterNetworkHostPrefix: t('ai:Cluster network host prefix'),
   serviceNetworkCidr: t('ai:Service network CIDR'),
-  apiVip: t('ai:API IP'),
-  ingressVip: t('ai:Ingress IP'),
+  apiVips: t('ai:API IP'),
+  ingressVips: t('ai:Ingress IP'),
   pullSecret: t('ai:Pull secret'),
   sshPublicKey: t('ai:SSH public key'),
   SNODisclaimer: t('ai:Single Node OpenShift disclaimer'),
@@ -161,6 +175,7 @@ export const hostValidationLabels = (t: TFunction): { [key in HostValidationId]:
   'no-skip-missing-disk': t('ai:No skip missing disk'),
   'time-synced-between-host-and-service': t('ai:Time synced between host and service'),
   'no-ip-collisions-in-network': t('ai:No IP collisions in network'),
+  'mce-requirements-satisfied': t('ai:Multicluster engine requirements'),
 });
 
 export const hostValidationFailureHints = (
@@ -208,11 +223,12 @@ export const hostValidationFailureHints = (
   'no-skip-installation-disk': '',
   'no-skip-missing-disk': '',
   'no-ip-collisions-in-network': '',
+  'mce-requirements-satisfied': '',
 });
 
 export const clusterValidationLabels = (
   t: TFunction,
-): { [key in ClusterValidationId]: string } => ({
+): { [key in ClusterValidationId]?: string } => ({
   'network-type-valid': t('ai:Valid network type'),
   'machine-cidr-defined': t('ai:Machine CIDR'),
   'cluster-cidr-defined': t('ai:Cluster CIDR'),
@@ -222,13 +238,9 @@ export const clusterValidationLabels = (
   'network-prefix-valid': t('ai:Valid network prefix'),
   'machine-cidr-equals-to-calculated-cidr': t('ai:Machine CIDR conforms expected'),
   'api-vips-defined': t('ai:API IP'),
-  'api-vip-defined': t('ai:API IP'),
   'api-vips-valid': t('ai:API IP validity'),
-  'api-vip-valid': t('ai:API IP validity'),
   'ingress-vips-defined': t('ai:Ingress IP'),
-  'ingress-vip-defined': t('ai:Ingress IP'),
   'ingress-vips-valid': t('ai:Ingress IP validity'),
-  'ingress-vip-valid': t('ai:Ingress IP validity'),
   'all-hosts-are-ready-to-install': t('ai:All hosts are ready to install'),
   'sufficient-masters-count': t('ai:Control plane nodes count'),
   'dns-domain-defined': t('ai:DNS domain'),
@@ -239,6 +251,7 @@ export const clusterValidationLabels = (
   'odf-requirements-satisfied': t('ai:ODF requirements'),
   'lvm-requirements-satisfied': t('ai:Logical Volume Manager requirements'),
   'cnv-requirements-satisfied': t('ai:CNV requirements'),
+  'mce-requirements-satisfied': t('ai:MCE requirements'),
 });
 
 export const clusterValidationGroupLabels = (
@@ -302,6 +315,7 @@ export const OPERATOR_NAME_LSO = 'lso';
 export const OPERATOR_NAME_ODF = 'odf';
 export const OPERATOR_NAME_LVM = 'lvm';
 export const OPERATOR_NAME_LVMS = 'lvms';
+export const OPERATOR_NAME_MCE = 'mce';
 
 const OperatorNames = [
   OPERATOR_NAME_CNV,
@@ -309,12 +323,14 @@ const OperatorNames = [
   OPERATOR_NAME_ODF,
   OPERATOR_NAME_LVM,
   OPERATOR_NAME_LVMS,
+  OPERATOR_NAME_MCE,
 ];
 export const ExposedOperatorNames = [
   OPERATOR_NAME_CNV,
   OPERATOR_NAME_ODF,
   OPERATOR_NAME_LVM,
   OPERATOR_NAME_LVMS,
+  OPERATOR_NAME_MCE,
 ];
 
 export type OperatorName = (typeof OperatorNames)[number];
@@ -349,6 +365,7 @@ export const operatorLabels = (
     [OPERATOR_NAME_LVM]: useLVMS
       ? t('ai:Logical Volume Manager Storage')
       : t('ai:Logical Volume Manager'),
+    [OPERATOR_NAME_MCE]: t('ai:Multicluster engine'),
   };
 };
 
@@ -367,6 +384,8 @@ export const CHANGE_ISO_PASSWORD_FILE_LINK =
 export const CUSTOM_MANIFESTS_HELP_LINK =
   'https://docs.openshift.com/container-platform/4.12/installing/install_config/installing-customizing.html';
 
-//TODO (mortegag): Change the link. Related to https://issues.redhat.com/browse/MGMT-13976
 export const HOW_TO_KNOW_IF_CLUSTER_SUPPORTS_MULTIPLE_CPU_ARCHS =
-  'https://57587--docspreview.netlify.app/openshift-enterprise/latest/post_installation_configuration/multi-architecture-configuration.html#multi-architecture-verifying-cluster-compatibility_multi-architecture-configuration';
+  'https://access.redhat.com/documentation/en-us/assisted_installer_for_openshift_container_platform/2022/html-single/assisted_installer_for_openshift_container_platform/index#checking-for-multiple-architectures_expanding-the-cluster';
+
+export const MCE_LINK =
+  'https://docs.openshift.com/container-platform/4.13/architecture/mce-overview-ocp.html';

package/lib/common/configurations.ts

@@ -0,0 +1,2 @@
+export const MAX_FILE_SIZE_BYTES = 1024 ** 2;
+export const MAX_FILE_SIZE_OFFSET_FACTOR = 2;

package/lib/common/features/featureGate.tsx

@@ -7,9 +7,9 @@ type AssistedInstallerFeatureType =
   | 'ASSISTED_INSTALLER_ODF_FEATURE'
   | 'ASSISTED_INSTALLER_CNV_FEATURE'
   | 'ASSISTED_INSTALLER_NETWORK_TYPE_SELECTION_FEATURE'
-  | 'ASSISTED_INSTALLER_PLATFORM_INTEGRATION_FEATURE'
   | 'ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE'
-  | 'ASSISTED_INSTALLER_MULTIARCH_SUPPORTED';
+  | 'ASSISTED_INSTALLER_MULTIARCH_SUPPORTED'
+  | 'ASSISTED_INSTALLER_PLATFORM_OCI';
 
 export type FeatureListType = {
   [key in AssistedInstallerFeatureType]?: boolean;
@@ -31,8 +31,8 @@ export const ACM_ENABLED_FEATURES: FeatureListType = {
   ASSISTED_INSTALLER_ODF_FEATURE: false,
   ASSISTED_INSTALLER_CNV_FEATURE: false,
   ASSISTED_INSTALLER_NETWORK_TYPE_SELECTION_FEATURE: false,
-  ASSISTED_INSTALLER_PLATFORM_INTEGRATION_FEATURE: false,
   ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE: false,
+  ASSISTED_INSTALLER_MULTIARCH_SUPPORTED: true,
 };
 
 // Hardcoded outside OCM
@@ -42,9 +42,9 @@ export const STANDALONE_DEPLOYMENT_ENABLED_FEATURES: FeatureListType = {
   ASSISTED_INSTALLER_ODF_FEATURE: true,
   ASSISTED_INSTALLER_CNV_FEATURE: true,
   ASSISTED_INSTALLER_NETWORK_TYPE_SELECTION_FEATURE: true,
-  ASSISTED_INSTALLER_PLATFORM_INTEGRATION_FEATURE: true,
   ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE: false,
   ASSISTED_INSTALLER_MULTIARCH_SUPPORTED: true,
+  ASSISTED_INSTALLER_PLATFORM_OCI: true,
 };
 
 export type FeatureGateContextType = {
@@ -59,10 +59,12 @@ export const FeatureGateContextProvider: React.FC<{
   features: FeatureListType;
 }> = ({ features, children }) => {
   // hardcoded defaults
+  // TODO (mortegag): Remove all multiarch capacity related code in the UI.
   const featuresWithDefaults: FeatureListType = {
     ASSISTED_INSTALLER_OCS_FEATURE: false,
     ASSISTED_INSTALLER_ODF_FEATURE: false,
     ASSISTED_INSTALLER_CNV_FEATURE: false,
+    ASSISTED_INSTALLER_MULTIARCH_SUPPORTED: true,
     ...features,
   };
 

package/lib/common/index.ts

@@ -1,3 +1,4 @@
+import './configurations';
 import './styles.css';
 import './utils';