Show only the allowed storage interfaces on Disk-modal

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/internal-actions.ts

@@ -1,3 +1,4 @@
+import { TemplateValidations } from 'packages/kubevirt-plugin/src/utils/validations/template/template-validations';
 import {
   CloudInitField,
   VMImportProvider,
@@ -208,4 +209,11 @@ export const vmWizardInternalActions: VMWizardInternalActions = {
     },
     type: InternalActionType.SetResults,
   }),
+  [InternalActionType.SetTemplateValidations]: (id, value: TemplateValidations[]) => ({
+    payload: {
+      id,
+      value,
+    },
+    type: InternalActionType.SetTemplateValidations,
+  }),
 };

frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/reducers.ts

@@ -251,6 +251,11 @@ export default (state, action: WizardInternalAction) => {
         [dialogID, 'tabs', VMWizardTab.VM_SETTINGS, 'value'],
         fromJS(payload.value),
       );
+    case InternalActionType.SetTemplateValidations:
+      return state.setIn(
+        [dialogID, 'commonData', 'dataIDReferences', 'templateValidations'],
+        payload.value,
+      );
     default:
       break;
   }

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/stateUpdate/vmSettings/vm-settings-tab-state-update.ts

@@ -1,4 +1,5 @@
 import { FLAGS } from '@console/shared';
+import { TemplateValidations } from '../../../../../utils/validations/template/template-validations';
 import { isWinToolsImage, getVolumeContainerImage } from '../../../../../selectors/vm';
 import {
   hasVmSettingsChanged,
@@ -20,6 +21,7 @@ import { ProvisionSource } from '../../../../../constants/vm/provision-source';
 import { getProviders } from '../../../provider-definitions';
 import { windowsToolsStorage } from '../../initial-state/storage-tab-initial-state';
 import { getStorages } from '../../../selectors/selectors';
+import { getTemplateValidations } from '../../validations/utils/templates-validations';
 import { prefillVmTemplateUpdater } from './prefill-vm-template-state-update';
 
 export const selectedUserTemplateUpdater = (options: UpdateOptions) => {
@@ -144,6 +146,25 @@ export const nativeK8sUpdater = ({ id, dispatch, getState, changedCommonData }:
   );
 };
 
+export const templateValidationsUpdater = (options: UpdateOptions) => {
+  const { id, prevState, dispatch, getState } = options;
+  const state = getState();
+  if (
+    !hasVmSettingsChanged(
+      prevState,
+      state,
+      id,
+      VMSettingsField.OPERATING_SYSTEM,
+      VMSettingsField.FLAVOR,
+      VMSettingsField.WORKLOAD_PROFILE,
+    )
+  ) {
+    return;
+  }
+  const validations: TemplateValidations[] = getTemplateValidations(options);
+  dispatch(vmWizardInternalActions[InternalActionType.SetTemplateValidations](id, validations));
+};
+
 export const updateVmSettingsState = (options: UpdateOptions) =>
   [
     ...(iGetCommonData(options.getState(), options.id, VMWizardProps.isProviderImport)
@@ -154,6 +175,7 @@ export const updateVmSettingsState = (options: UpdateOptions) =>
     flavorUpdater,
     osUpdater,
     nativeK8sUpdater,
+    templateValidationsUpdater,
   ].forEach((updater) => {
     updater && updater(options);
   });

frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/redux/types.ts

@@ -53,6 +53,7 @@ export enum InternalActionType {
   SetNetworks = 'KubevirtVMWizardSetNetworks',
   SetStorages = 'KubevirtVMWizardSetStorages',
   SetResults = 'KubevirtVMWizardSetResults',
+  SetTemplateValidations = 'TemplateValidations',
 }
 
 export type WizardInternalAction = {

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

@@ -0,0 +1,42 @@
+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 { 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 iUserTemplates = iGetLoadedCommonData(state, id, VMWizardProps.userTemplates);
+  const iCommonTemplates = iGetLoadedCommonData(state, id, VMWizardProps.commonTemplates);
+
+  const templates = iGetRelevantTemplates(iUserTemplates, iCommonTemplates, {
+    userTemplateName,
+    os,
+    workload,
+    flavor,
+  });
+
+  if (templates.size > 0 && os && workload) {
+    // templates are sorted by relevance if only flavor is missing
+    return getValidationsFromTemplates(templates.toArray());
+  }
+
+  return getValidationsFromTemplates([templates.first()]);
+};

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,22 @@ 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, 0);
   }
 
   return null;
@@ -177,6 +166,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/selectors/selectors.ts

@@ -1,5 +1,6 @@
 import { get } from 'lodash';
 import { Map } from 'immutable';
+import { TemplateValidations } from 'packages/kubevirt-plugin/src/utils/validations/template/template-validations';
 import { iGetIn, immutableListToShallowJS } from '../../../utils/immutable';
 import {
   VMWizardNetwork,
@@ -50,3 +51,6 @@ export const getStoragesWithWrappers = (state, id: string): VMWizardStorageWithW
     persistentVolumeClaim,
     ...rest,
   }));
+
+export const getTemplateValidations = (state, id: string): TemplateValidations[] =>
+  iGetIn(getCreateVMWizards(state), [id, 'commonData', 'dataIDReferences', 'templateValidations']);

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',