Show VMI details

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

@@ -40,7 +40,6 @@ import {
   parseCPU,
   isWinToolsImage,
 } from '../../../../../selectors/vm';
-import { selectVM } from '../../../../../selectors/vm-template/selectors';
 import {
   getTemplateFlavors,
   getTemplateOperatingSystems,
@@ -62,6 +61,7 @@ import { DataVolumeWrapper } from '../../../../../k8s/wrapper/vm/data-volume-wra
 import { V1alpha1DataVolume } from '../../../../../types/vm/disk/V1alpha1DataVolume';
 import { joinIDs } from '../../../../../utils';
 import { VM_TEMPLATE_NAME_PARAMETER } from '../../../../../constants/vm-templates';
+import { selectVM } from '../../../../../selectors/vm-template/basic';
 
 export const prefillVmTemplateUpdater = ({ id, dispatch, getState }: UpdateOptions) => {
   const state = getState();

frontend/packages/kubevirt-plugin/src/components/create-vm-wizard/selectors/template.ts

@@ -8,6 +8,8 @@ import { VMSettingsField, VMWizardProps } from '../types';
 import { iGetLoadedCommonData } from './immutable/selectors';
 import { iGetVmSettingAttribute, iGetVmSettingValue } from './immutable/vm-settings';
 
+const { warn } = console;
+
 const getValidationsFromTemplates = (templates): TemplateValidations[] =>
   templates.map(
     (relevantTemplate) => new TemplateValidations(iGetTemplateValidations(relevantTemplate)),
@@ -52,7 +54,7 @@ export const getTemplateValidation = (state, id: string): TemplateValidations =>
   const templateValidations = getTemplateValidations(state, id);
   if (templateValidations && templateValidations.length > 0) {
     templateValidations.length > 1 &&
-      console.warn('WARNING: getTemplateValidation: multiple template validations detected!');
+      warn('WARNING: getTemplateValidation: multiple template validations detected!');
     return templateValidations[0];
   }
 

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

@@ -4,7 +4,7 @@ import { getStringEnumValues } from '../../utils/types';
 import { V1Network, V1NetworkInterface, VMKind } from '../../types/vm';
 import { NetworkInterfaceWrapper } from '../../k8s/wrapper/vm/network-interface-wrapper';
 import { NetworkWrapper } from '../../k8s/wrapper/vm/network-wrapper';
-import { UIDiskValidation, UINetworkInterfaceValidation } from '../../utils/validations/vm';
+import { UINetworkInterfaceValidation } from '../../utils/validations/vm/nic';
 import { V1Disk } from '../../types/vm/disk/V1Disk';
 import { V1Volume } from '../../types/vm/disk/V1Volume';
 import { V1alpha1DataVolume } from '../../types/vm/disk/V1alpha1DataVolume';
@@ -14,6 +14,7 @@ import { DataVolumeWrapper } from '../../k8s/wrapper/vm/data-volume-wrapper';
 import { IDReferences } from '../../utils/redux/id-reference';
 import { V1PersistentVolumeClaim } from '../../types/vm/disk/V1PersistentVolumeClaim';
 import { PersistentVolumeClaimWrapper } from '../../k8s/wrapper/vm/persistent-volume-claim-wrapper';
+import { UIDiskValidation } from '../../utils/validations/vm/types';
 
 export enum VMWizardTab { // order important
   VM_SETTINGS = 'VM_SETTINGS',

frontend/packages/kubevirt-plugin/src/components/dashboards-page/vm-dashboard/vm-activity.tsx

@@ -17,12 +17,12 @@ import {
   withDashboardResources,
   DashboardItemProps,
 } from '@console/internal/components/dashboard/with-dashboard-resources';
-import { VMKind } from '../../../types';
 import { VirtualMachineModel } from '../../../models';
 import { getVmEventsFilters } from '../../../selectors/event';
 import { VMDashboardContext } from '../../vms/vm-dashboard-context';
+import { VMILikeEntityKind } from '../../../types/vmLike';
 
-const combinedVmFilter = (vm: VMKind): EventFilterFuncion => (event) =>
+const combinedVmFilter = (vm: VMILikeEntityKind): EventFilterFuncion => (event) =>
   getVmEventsFilters(vm).some((filter) => filter(event.involvedObject));
 
 const getEventsResource = (namespace: string): FirehoseResource => ({
@@ -56,13 +56,14 @@ const RecentEvent = withDashboardResources<RecentEventProps>(
 );
 
 export const VMActivityCard: React.FC = () => {
-  const { vm } = React.useContext(VMDashboardContext);
+  const { vm, vmi } = React.useContext(VMDashboardContext);
+  const vmiLike = vm || vmi;
 
   const [paused, setPaused] = React.useState(false);
   const togglePause = React.useCallback(() => setPaused(!paused), [paused]);
 
-  const name = getName(vm);
-  const namespace = getNamespace(vm);
+  const name = getName(vmiLike);
+  const namespace = getNamespace(vmiLike);
   const viewEventsLink = `${resourcePath(VirtualMachineModel.kind, name, namespace)}/events`;
 
   return (
@@ -76,7 +77,7 @@ export const VMActivityCard: React.FC = () => {
       </DashboardCardHeader>
       <DashboardCardBody>
         <ActivityBody>
-          <RecentEvent vm={vm} paused={paused} setPaused={setPaused} />
+          <RecentEvent vm={vmiLike} paused={paused} setPaused={setPaused} />
         </ActivityBody>
       </DashboardCardBody>
     </DashboardCard>
@@ -86,7 +87,7 @@ export const VMActivityCard: React.FC = () => {
 type EventFilterFuncion = (event: EventKind) => boolean;
 
 type RecentEventProps = DashboardItemProps & {
-  vm: VMKind;
+  vm: VMILikeEntityKind;
   paused: boolean;
   setPaused: (paused: boolean) => void;
 };

frontend/packages/kubevirt-plugin/src/components/dashboards-page/vm-dashboard/vm-alerts.tsx

@@ -15,7 +15,7 @@ const isGuestAgentInstalled = (vmi: VMIKind) => {
 };
 
 export const VMAlerts: React.FC<VMAlertsProps> = ({ vm, vmi }) => (
-  <AlertsBody emptyMessage="No VM messages" isLoading={!vm}>
+  <AlertsBody emptyMessage="No VM messages" isLoading={!(vm || vmi)}>
     {vmi && vmi.status && !isGuestAgentInstalled(vmi) && (
       <StatusItem
         Icon={BlueInfoCircleIcon}

frontend/packages/kubevirt-plugin/src/components/dashboards-page/vm-dashboard/vm-details-card.tsx

@@ -15,24 +15,23 @@ import {
   resourcePath,
 } from '@console/internal/components/utils';
 import { VMDashboardContext } from '../../vms/vm-dashboard-context';
-import { isVMRunning } from '../../../selectors/vm';
-import { getVMStatus } from '../../../statuses/vm/vm';
 import { VirtualMachineModel } from '../../../models';
-import { getVmiIpAddressesString } from '../../ip-addresses';
+import { getVmiIpAddresses } from '../../../selectors/vmi/ip-address';
 import { VM_DETAIL_OVERVIEW_HREF } from '../../../constants';
+import { findVMPod } from '../../../selectors/pod/selectors';
 
 export const VMDetailsCard: React.FC<VMDetailsCardProps> = () => {
   const vmDashboardContext = React.useContext(VMDashboardContext);
-  const { vm, vmi, pods, migrations } = vmDashboardContext;
+  const { vm, vmi, pods } = vmDashboardContext;
+  const vmiLike = vm || vmi;
 
-  const vmStatus = getVMStatus({ vm, vmi, pods, migrations });
-  const { launcherPod } = vmStatus;
+  const launcherPod = findVMPod(vmiLike, pods);
 
-  const ipAddrs = getVmiIpAddressesString(vmi, vmStatus);
+  const ipAddrs = getVmiIpAddresses(vmi).join(', ');
 
-  const isNodeLoading = !vm || !pods || !vmStatus;
-  const name = getName(vm);
-  const namespace = getNamespace(vm);
+  const isNodeLoading = !vmiLike || !pods;
+  const name = getName(vmiLike);
+  const namespace = getNamespace(vmiLike);
 
   const viewAllLink = `${resourcePath(
     VirtualMachineModel.kind,
@@ -48,26 +47,32 @@ export const VMDetailsCard: React.FC<VMDetailsCardProps> = () => {
       </DashboardCardHeader>
       <DashboardCardBody isLoading={false}>
         <DetailsBody>
-          <DetailItem title="Name" error={false} isLoading={!vm} valueClassName="co-select-to-copy">
+          <DetailItem
+            title="Name"
+            error={false}
+            isLoading={!vmiLike}
+            valueClassName="co-select-to-copy"
+          >
             {name}
           </DetailItem>
-          <DetailItem title="Namespace" error={false} isLoading={!vm}>
-            <ResourceLink kind="Namespace" name={namespace} title={getUID(vm)} namespace={null} />
+          <DetailItem title="Namespace" error={false} isLoading={!vmiLike}>
+            <ResourceLink
+              kind="Namespace"
+              name={namespace}
+              title={getUID(vmiLike)}
+              namespace={null}
+            />
           </DetailItem>
-          <DetailItem title="Created" error={false} isLoading={!vm}>
-            <Timestamp timestamp={getCreationTimestamp(vm)} />
+          <DetailItem title="Created" error={false} isLoading={!vmiLike}>
+            <Timestamp timestamp={getCreationTimestamp(vmiLike)} />
           </DetailItem>
-          <DetailItem
-            title="Node"
-            error={!isNodeLoading && (!launcherPod || !isVMRunning(vm))}
-            isLoading={isNodeLoading}
-          >
+          <DetailItem title="Node" error={!isNodeLoading && !launcherPod} isLoading={isNodeLoading}>
             {launcherPod && <NodeLink name={getNodeName(launcherPod)} />}
           </DetailItem>
           <DetailItem
             title="IP Address"
             error={!ipAddrs}
-            isLoading={!vm}
+            isLoading={!vmiLike}
             valueClassName="co-select-to-copy"
           >
             {ipAddrs}

frontend/packages/kubevirt-plugin/src/components/dashboards-page/vm-dashboard/vm-inventory-card.tsx

@@ -9,25 +9,26 @@ import { getName, getNamespace } from '@console/shared';
 import InventoryItem from '@console/shared/src/components/dashboard/inventory-card/InventoryItem';
 import { resourcePath } from '@console/internal/components/utils';
 import { VMDashboardContext } from '../../vms/vm-dashboard-context';
+import { getVMLikeModel } from '../../../selectors/vm/vmlike';
 import { getNetworks, getDisks } from '../../../selectors/vm';
 import { getVMINetworks, getVMIDisks } from '../../../selectors/vmi';
-import { VirtualMachineModel } from '../../../models';
 import { VM_DETAIL_DISKS_HREF, VM_DETAIL_NETWORKS_HREF } from '../../../constants';
 
 export const VMInventoryCard: React.FC<VMInventoryCardProps> = () => {
   const vmDashboardContext = React.useContext(VMDashboardContext);
   const { vm, vmi } = vmDashboardContext;
+  const vmiLike = vm || vmi;
 
-  const isLoading = !vm;
-  const name = getName(vm);
-  const namespace = getNamespace(vm);
+  const isLoading = !vmiLike;
+  const name = getName(vmiLike);
+  const namespace = getNamespace(vmiLike);
 
   // prefer vmi over vm if available (means: is running)
-  const nicCount = vmi && vmi.spec ? getVMINetworks(vmi).length : getNetworks(vm).length;
-  const diskCount = vmi && vmi.spec ? getVMIDisks(vmi).length : getDisks(vm).length;
+  const nicCount = vm ? getNetworks(vm).length : getVMINetworks(vmi).length;
+  const diskCount = vm ? getDisks(vm).length : getVMIDisks(vmi).length;
   // TODO: per design, snapshots should be added here (snapshots are not implemented at all atm)
 
-  const basePath = resourcePath(VirtualMachineModel.kind, name, namespace);
+  const basePath = resourcePath(getVMLikeModel(vmiLike).kind, name, namespace);
   const DisksTitle = React.useCallback(
     ({ children }) => <Link to={`${basePath}/${VM_DETAIL_DISKS_HREF}`}>{children}</Link>,
     [basePath],

frontend/packages/kubevirt-plugin/src/components/dashboards-page/vm-dashboard/vm-utilization.tsx

@@ -34,10 +34,11 @@ const humanizeCpuCores = (v) => {
 export const VMUtilizationCard: React.FC = () => {
   const [timestamps, setTimestamps] = React.useState<Date[]>();
   const [duration, setDuration] = useMetricDuration();
-  const { vm, pods } = React.useContext(VMDashboardContext);
-  const vmName = getName(vm);
-  const namespace = getNamespace(vm);
-  const launcherPodName = getName(findVMPod(vm, pods));
+  const { vm, vmi, pods } = React.useContext(VMDashboardContext);
+  const vmiLike = vm || vmi;
+  const vmName = getName(vmiLike);
+  const namespace = getNamespace(vmiLike);
+  const launcherPodName = getName(findVMPod(vmiLike, pods));
   const queries = React.useMemo(
     () =>
       getUtilizationQueries({

frontend/packages/kubevirt-plugin/src/components/flavor-text.tsx

@@ -1,18 +1,22 @@
 import * as _ from 'lodash';
 import { convertToBaseValue, humanizeBinaryBytes } from '@console/internal/components/utils';
-import { getFlavor, vCPUCount, getCPU, getMemory, asVM } from '../selectors/vm';
-import { VMLikeEntityKind } from '../types';
+import { vCPUCount } from '../selectors/vm';
+import { CPURaw } from '../types/vm';
 
-export const getFlavorText = (vmLike: VMLikeEntityKind) => {
-  const vm = asVM(vmLike);
-
-  const flavor = _.capitalize(getFlavor(vmLike));
-
-  const vcpusCount = vCPUCount(getCPU(vm));
+export const getFlavorText = ({
+  cpu,
+  memory,
+  flavor,
+}: {
+  cpu: CPURaw;
+  memory: string;
+  flavor: string;
+}) => {
+  const vcpusCount = vCPUCount(cpu);
   const vcpusText = `${vcpusCount} vCPU${vcpusCount > 1 ? 's' : ''}`;
 
-  const memoryBase = convertToBaseValue(getMemory(vm));
+  const memoryBase = convertToBaseValue(memory);
   const memoryText = humanizeBinaryBytes(memoryBase).string;
 
-  return `${flavor || ''}${flavor ? ': ' : ''}${vcpusText}, ${memoryText} Memory`;
+  return `${_.capitalize(flavor) || ''}${flavor ? ': ' : ''}${vcpusText}, ${memoryText} Memory`;
 };

frontend/packages/kubevirt-plugin/src/components/modals/boot-order-modal/boot-order-modal.tsx

@@ -6,7 +6,8 @@ import { withHandlePromise, HandlePromiseProps } from '@console/internal/compone
 import { ModalComponentProps } from '@console/internal/components/factory';
 import { k8sPatch } from '@console/internal/module/k8s';
 import { PatchBuilder, PatchOperation } from '@console/shared/src/k8s';
-import { VMLikeEntityKind, BootableDeviceType } from '../../../types';
+import { BootableDeviceType } from '../../../types';
+import { VMLikeEntityKind } from '../../../types/vmLike';
 import { getVMLikeModel, getDevices } from '../../../selectors/vm';
 import { getVMLikePatches } from '../../../k8s/patches/vm-template';
 import { BootOrder, deviceKey } from '../../boot-order';

frontend/packages/kubevirt-plugin/src/components/modals/cdrom-vm-modal/cdrom-modal.tsx

@@ -22,11 +22,13 @@ import {
   isVMRunning,
 } from '../../../selectors/vm/selectors';
 import { isValidationError, validateURL } from '../../../utils/validations/common';
-import { VMKind, VMLikeEntityKind } from '../../../types';
+import { VMLikeEntityKind } from '../../../types/vmLike';
 import { CDRomRow } from './cdrom-row';
 import { getAvailableCDName } from './helpers';
-import { initialDisk, WINTOOLS_CONTAINER_NAMES, StorageType, CD, CDMap } from './constants';
+import { initialDisk, WINTOOLS_CONTAINER_NAMES, StorageType } from './constants';
 import './cdrom-modal.scss';
+import { CD, CDMap } from './types';
+import { VMKind } from '../../../types/vm';
 
 export const CDRomModal = withHandlePromise((props: CDRomModalProps) => {
   const {
@@ -54,13 +56,13 @@ export const CDRomModal = withHandlePromise((props: CDRomModalProps) => {
         };
         const container = getContainerImageByDisk(vm, name);
         if (container) {
-          if (_.includes(WINTOOLS_CONTAINER_NAMES, container))
+          if (_.includes(WINTOOLS_CONTAINER_NAMES, container)) {
             cd = {
               ...cd,
               type: StorageType.WINTOOLS,
               windowsTools: container,
             };
-          else {
+          } else {
             cd = { ...cd, type: StorageType.CONTAINER, container };
           }
         }

frontend/packages/kubevirt-plugin/src/components/modals/cdrom-vm-modal/cdrom-row.tsx

@@ -16,7 +16,8 @@ import { FirehoseResult } from '@console/internal/components/utils';
 import { K8sResourceSelectRow } from '../../form/k8s-resource-select-row';
 import { VMKind } from '../../../types';
 import { FormSelectPlaceholderOption } from '../../form/form-select-placeholder-option';
-import { StorageType, CD, CD_SIZE, CD_STORAGE_CLASS } from './constants';
+import { StorageType, CD_SIZE, CD_STORAGE_CLASS } from './constants';
+import { CD } from './types';
 
 export const CDRomRow: React.FC<CDRomRowProps> = ({
   cd,

frontend/packages/kubevirt-plugin/src/components/modals/cdrom-vm-modal/constants.ts

@@ -1,28 +1,3 @@
-import { V1CDRomTarget } from '../../../types/vm/disk/V1CDRomTarget';
-
-export type CD = {
-  name: string;
-  bootOrder?: number;
-  cdrom?: V1CDRomTarget;
-
-  // UI
-  changed?: boolean;
-  newCD?: boolean;
-  pvc?: string;
-  container?: string;
-  type?: string;
-  bus?: string;
-  url?: string;
-  windowsTools?: string;
-  storageClass?: string;
-  size?: string | number;
-  isURLValid?: boolean;
-};
-
-export type CDMap = {
-  [name: string]: CD;
-};
-
 export const CD_SIZE = 'size';
 export const CD_STORAGE_CLASS = 'storageClass';
 

frontend/packages/kubevirt-plugin/src/components/modals/cdrom-vm-modal/helpers.ts

@@ -1,4 +1,4 @@
-import { CD } from './constants';
+import { CD } from './types';
 
 export const getAvailableCDName = (cds: CD[]) => {
   const cdSet = new Set(cds.map((cd) => cd.name));

frontend/packages/kubevirt-plugin/src/components/modals/cdrom-vm-modal/types.ts

@@ -0,0 +1,24 @@
+import { V1CDRomTarget } from '../../../types/vm/disk/V1CDRomTarget';
+
+export type CD = {
+  name: string;
+  bootOrder?: number;
+  cdrom?: V1CDRomTarget;
+
+  // UI
+  changed?: boolean;
+  newCD?: boolean;
+  pvc?: string;
+  container?: string;
+  type?: string;
+  bus?: string;
+  url?: string;
+  windowsTools?: string;
+  storageClass?: string;
+  size?: string | number;
+  isURLValid?: boolean;
+};
+
+export type CDMap = {
+  [name: string]: CD;
+};