kubevirt: enhance memory validation and template selection

frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/create-vm-wizard.tsx

@@ -289,16 +289,15 @@ export class CreateVMWizardComponent extends React.Component<CreateVMWizardCompo
     const storages = immutableListToShallowJS(
       iGetIn(this.props.stepData, [VMWizardTab.STORAGE, 'value']),
     );
-    const templates = immutableListToShallowJS<TemplateKind>(
-      concatImmutableLists(
-        iGetLoadedData(this.props[VMWizardProps.commonTemplates]),
-        iGetLoadedData(this.props[VMWizardProps.userTemplates]),
-      ),
-    );
 
+    const iUserTemplates = iGetLoadedData(this.props[VMWizardProps.userTemplates]);
+    const iCommonTemplates = iGetLoadedData(this.props[VMWizardProps.commonTemplates]);
     let promise;
 
     if (isProviderImport) {
+      const templates = immutableListToShallowJS<TemplateKind>(
+        concatImmutableLists(iUserTemplates, iCommonTemplates),
+      );
       const { interOPVMSettings, interOPNetworks, interOPStorages } = await kubevirtInterOP({
         vmSettings,
         networks,
@@ -323,7 +322,8 @@ export class CreateVMWizardComponent extends React.Component<CreateVMWizardCompo
         vmSettings,
         networks,
         storages,
-        templates,
+        iUserTemplates,
+        iCommonTemplates,
         namespace: activeNamespace,
         openshiftFlag,
       });

frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/stateUpdate/vmSettings/prefill-vm-template-state-update.ts

@@ -85,6 +85,8 @@ export const prefillVmTemplateUpdater = ({ id, dispatch, getState }: UpdateOptio
     [VMSettingsField.WORKLOAD_PROFILE]: { value: null },
     [VMSettingsField.PROVISION_SOURCE_TYPE]: { value: isProviderImport ? undefined : null },
     [VMSettingsField.HOSTNAME]: { value: null },
+    [VMSettingsField.CPU]: { value: null },
+    [VMSettingsField.MEMORY]: { value: null },
   };
 
   // filter out oldTemplates

frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/validations/utils/templates-validations.ts

@@ -0,0 +1,56 @@
+import { UpdateOptions } from '../../types';
+import {
+  iGetVmSettingAttribute,
+  iGetVmSettingValue,
+} from '../../../selectors/immutable/vm-settings';
+import { iGetLoadedCommonData } from '../../../selectors/immutable/selectors';
+import { VMSettingsField, VMWizardProps } from '../../../types';
+import { iGetTemplateValidations } from '../../../../../selectors/immutable/template/selectors';
+import {
+  iGetRelevantTemplate,
+  iGetRelevantTemplates,
+} from '../../../../../selectors/immutable/template/combined';
+import { TemplateValidations } from '../../../../../utils/validations/template/template-validations';
+
+const getValidationsFromTemplates = (templates): TemplateValidations[] =>
+  templates.map(
+    (relevantTemplate) => new TemplateValidations(iGetTemplateValidations(relevantTemplate)),
+  );
+
+export const getTemplateValidations = (options: UpdateOptions): TemplateValidations[] => {
+  const { getState, id } = options;
+  const state = getState();
+
+  const userTemplateName = iGetVmSettingValue(state, id, VMSettingsField.USER_TEMPLATE);
+  const os = iGetVmSettingAttribute(state, id, VMSettingsField.OPERATING_SYSTEM);
+  const flavor = iGetVmSettingAttribute(state, id, VMSettingsField.FLAVOR);
+  const workload = iGetVmSettingAttribute(state, id, VMSettingsField.WORKLOAD_PROFILE);
+
+  const relevantOptions = {
+    userTemplateName,
+    os,
+    workload,
+    flavor,
+  };
+
+  const iUserTemplates = iGetLoadedCommonData(state, id, VMWizardProps.userTemplates);
+  const iCommonTemplates = iGetLoadedCommonData(state, id, VMWizardProps.commonTemplates);
+
+  if (userTemplateName || (flavor && os && workload)) {
+    // all information is filled to select a final template
+    const relevantTemplate = iGetRelevantTemplate(
+      iUserTemplates,
+      iCommonTemplates,
+      relevantOptions,
+    );
+    return getValidationsFromTemplates(relevantTemplate ? [relevantTemplate] : []);
+  }
+
+  const relevantTemplates = iGetRelevantTemplates(
+    iUserTemplates,
+    iCommonTemplates,
+    relevantOptions,
+  );
+
+  return getValidationsFromTemplates(relevantTemplates.toArray());
+};

frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/validations/vm-settings-tab-validation.ts

@@ -41,11 +41,10 @@ import {
 import { validatePositiveInteger } from '../../../../utils/validations/common';
 import { pluralize } from '../../../../utils/strings';
 import { vmSettingsOrder } from '../initial-state/vm-settings-tab-initial-state';
+import { TemplateValidations } from '../../../../utils/validations/template/template-validations';
+import { combineIntegerValidationResults } from '../../../../utils/validations/template/utils';
 import { getValidationUpdate } from './utils';
-import {
-  getTemplateValidations,
-  runValidation,
-} from './common-template-validations/common-templates-validations';
+import { getTemplateValidations } from './utils/templates-validations';
 
 const validateVm: VmSettingsValidator = (field, options) => {
   const { getState, id } = options;
@@ -101,32 +100,25 @@ export const validateOperatingSystem: VmSettingsValidator = (field) => {
 
 const memoryValidation: VmSettingsValidator = (field, options): ValidationObject => {
   const memValueGB = iGetFieldValue(field);
-  if (!memValueGB) {
+  if (memValueGB == null || memValueGB === '') {
     return null;
   }
   const memValueBytes = memValueGB * 1024 ** 3;
-  const validations = getTemplateValidations(options, VMSettingsField.MEMORY);
+  const validations = getTemplateValidations(options);
   if (validations.length === 0) {
-    return null;
+    validations.push(new TemplateValidations()); // add empty validation for positive integer if it is missing one
   }
 
-  const validationResult = runValidation(validations, memValueBytes);
-
-  if (!validationResult.isValid) {
-    // Must have failed all validations, including first one:
-    const validation = validations[0];
-    let customMessage = validationResult.errorMsg;
-
-    if ('min' in validation && 'max' in validation) {
-      customMessage = `Memory must be between ${validation.min / 1024 ** 3}GB and ${validation.max /
-        1024 ** 3} GB`;
-    } else if ('min' in validation) {
-      customMessage = `Memory must be above ${validation.min / 1024 ** 3}GB`;
-    } else if ('max' in validation) {
-      customMessage = `Memory must be below ${validation.max / 1024 ** 3}GB`;
-    }
+  const validationResults = validations
+    .map((v) => v.validateMemory(memValueBytes))
+    .filter(({ isValid }) => !isValid);
 
-    return asValidationObject(customMessage, ValidationErrorType.Error);
+  if (validationResults.length === validations.length) {
+    // every template failed its validations - we cannot choose one
+    return combineIntegerValidationResults(validationResults, {
+      defaultMin: 0,
+      isDefaultMinInclusive: false,
+    });
   }
 
   return null;
@@ -177,6 +169,7 @@ const validationConfig: VMSettingsValidationConfig = {
       VMSettingsField.OPERATING_SYSTEM,
       VMSettingsField.WORKLOAD_PROFILE,
     ],
+    detectCommonDataChanges: [VMWizardProps.userTemplates, VMWizardProps.commonTemplates],
     validator: memoryValidation,
   },
 };

frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/strings/vm-settings.ts

@@ -24,7 +24,7 @@ export const titleResolver: VMSettingsRenderableFieldResolver = {
   [VMSettingsField.IMAGE_URL]: 'URL',
   [VMSettingsField.OPERATING_SYSTEM]: 'Operating System',
   [VMSettingsField.FLAVOR]: 'Flavor',
-  [VMSettingsField.MEMORY]: 'Memory (GB)',
+  [VMSettingsField.MEMORY]: 'Memory (GiB)',
   [VMSettingsField.CPU]: 'CPUs',
   [VMSettingsField.WORKLOAD_PROFILE]: 'Workload Profile',
   [VMSettingsField.START_VM]: 'Start virtual machine on creation',

frontend/packages/kubevirt-plugin/src/k8s/requests/vm/create/common.ts

@@ -21,16 +21,21 @@ import { MutableVMWrapper } from '../../../wrapper/vm/vm-wrapper';
 import { getTemplateOperatingSystems } from '../../../../selectors/vm-template/advanced';
 import { MutableVMTemplateWrapper } from '../../../wrapper/vm/vm-template-wrapper';
 import { operatingSystemsNative } from '../../../../components/create-vm-wizard/native/consts';
+import { concatImmutableLists, immutableListToShallowJS } from '../../../../utils/immutable';
 import { CreateVMEnhancedParams } from './types';
 
 export const initializeCommonMetadata = (
-  { vmSettings, templates, openshiftFlag }: CreateVMEnhancedParams,
+  { vmSettings, iUserTemplates, openshiftFlag, iCommonTemplates }: CreateVMEnhancedParams,
   entity: MutableVMWrapper | MutableVMTemplateWrapper,
   template?: TemplateKind,
 ) => {
   const settings = asSimpleSettings(vmSettings);
   const operatingSystems = openshiftFlag
-    ? getTemplateOperatingSystems(templates)
+    ? getTemplateOperatingSystems(
+        immutableListToShallowJS<TemplateKind>(
+          concatImmutableLists(iUserTemplates, iCommonTemplates),
+        ),
+      )
     : operatingSystemsNative;
   const osID = settings[VMSettingsField.OPERATING_SYSTEM];
   const osName = (operatingSystems.find(({ id }) => id === osID) || {}).name;

frontend/packages/kubevirt-plugin/src/k8s/requests/vm/create/create.ts

@@ -21,21 +21,24 @@ import { buildOwnerReference } from '../../../../utils';
 import { selectVM } from '../../../../selectors/vm-template/selectors';
 import { MutableVMWrapper } from '../../../wrapper/vm/vm-wrapper';
 import { ProcessedTemplatesModel } from '../../../../models/models';
-import { findTemplate } from './selectors';
+import { toShallowJS } from '../../../../utils/immutable';
+import { iGetRelevantTemplate } from '../../../../selectors/immutable/template/combined';
 import { CreateVMEnhancedParams, CreateVMParams } from './types';
 import { initializeVM } from './initialize-vm';
 import { initializeCommonMetadata, initializeCommonVMMetadata } from './common';
 
 export const getInitializedVMTemplate = (params: CreateVMEnhancedParams) => {
-  const { vmSettings, templates } = params;
+  const { vmSettings, iCommonTemplates, iUserTemplates } = params;
   const settings = asSimpleSettings(vmSettings);
 
-  const temp = findTemplate(templates, {
-    userTemplateName: settings[VMSettingsField.USER_TEMPLATE],
-    workload: settings[VMSettingsField.WORKLOAD_PROFILE],
-    flavor: settings[VMSettingsField.FLAVOR],
-    os: settings[VMSettingsField.OPERATING_SYSTEM],
-  });
+  const temp = toShallowJS(
+    iGetRelevantTemplate(iUserTemplates, iCommonTemplates, {
+      userTemplateName: settings[VMSettingsField.USER_TEMPLATE],
+      workload: settings[VMSettingsField.WORKLOAD_PROFILE],
+      flavor: settings[VMSettingsField.FLAVOR],
+      os: settings[VMSettingsField.OPERATING_SYSTEM],
+    }),
+  );
 
   if (!temp) {
     return {};

frontend/packages/kubevirt-plugin/src/k8s/requests/vm/create/types.ts

@@ -1,14 +1,17 @@
-import { ConfigMapKind, TemplateKind } from '@console/internal/module/k8s';
+import { ConfigMapKind } from '@console/internal/module/k8s';
+import { Map as ImmutableMap } from 'immutable';
 import { EnhancedK8sMethods } from '../../../enhancedK8sMethods/enhancedK8sMethods';
 import { VMSettings } from '../../../../components/create-vm-wizard/redux/initial-state/types';
 import { VMWizardNetwork, VMWizardStorage } from '../../../../components/create-vm-wizard/types';
+import { ITemplate } from '../../../../types/template';
 
 export type CreateVMParams = {
   enhancedK8sMethods: EnhancedK8sMethods;
   vmSettings: VMSettings;
   networks: VMWizardNetwork[];
   storages: VMWizardStorage[];
-  templates: TemplateKind[];
+  iUserTemplates: ImmutableMap<string, ITemplate>;
+  iCommonTemplates: ImmutableMap<string, ITemplate>;
   namespace: string;
   openshiftFlag: boolean;
 };