Set the instance type on the VM

Set the selected instance type if exists on the VM. First we will try to find the namespaced instance type. If not found, we will lookup for the cluster wide one. Once the instance type is set, we skip setting the CPU and memory requested resources. Signed-off-by: Liran Rotenberg <[email protected]>
kubev2v · Mar 24, 2024 · f253c83 · f253c83
1 parent c533185
commit f253c83
Show file tree

Hide file tree

Showing 5 changed files with 92 additions and 5 deletions.
diff --git a/pkg/controller/plan/adapter/openstack/builder.go b/pkg/controller/plan/adapter/openstack/builder.go
@@ -429,6 +429,9 @@ func (r *Builder) mapResources(vm *model.Workload, object *cnv.VirtualMachineSpe
 			object.Template.Spec.Domain.CPU.IsolateEmulatorThread = true
 		}
 	}
+	if object.Instancetype != nil {
+		return
+	}
 
 	// Set CPU Sockets/Cores/Threads and Memory requests
 	// TODO support NUMA, CPU pinning

diff --git a/pkg/controller/plan/adapter/ova/builder.go b/pkg/controller/plan/adapter/ova/builder.go
@@ -307,6 +307,9 @@ func (r *Builder) mapInput(object *cnv.VirtualMachineSpec) {
 }
 
 func (r *Builder) mapMemory(vm *model.VM, object *cnv.VirtualMachineSpec) error {
+	if object.Instancetype != nil {
+		return nil
+	}
 	var memoryBytes int64
 	memoryBytes, err := getResourceCapacity(int64(vm.MemoryMB), vm.MemoryUnits)
 	if err != nil {
@@ -326,6 +329,9 @@ func (r *Builder) mapCPU(vm *model.VM, object *cnv.VirtualMachineSpec) {
 		vm.CoresPerSocket = 1
 	}
 	object.Template.Spec.Domain.Machine = &cnv.Machine{Type: "q35"}
+	if object.Instancetype != nil {
+		return
+	}
 	object.Template.Spec.Domain.CPU = &cnv.CPU{
 		Sockets: uint32(vm.CpuCount / vm.CoresPerSocket),
 		Cores:   uint32(vm.CoresPerSocket),

diff --git a/pkg/controller/plan/adapter/ovirt/builder.go b/pkg/controller/plan/adapter/ovirt/builder.go
@@ -362,6 +362,9 @@ func (r *Builder) mapClock(vm *model.Workload, object *cnv.VirtualMachineSpec) {
 }
 
 func (r *Builder) mapMemory(vm *model.Workload, object *cnv.VirtualMachineSpec) {
+	if object.Instancetype != nil {
+		return
+	}
 	reservation := resource.NewQuantity(vm.Memory, resource.BinarySI)
 	object.Template.Spec.Domain.Resources = cnv.ResourceRequirements{
 		Requests: map[core.ResourceName]resource.Quantity{
@@ -371,11 +374,6 @@ func (r *Builder) mapMemory(vm *model.Workload, object *cnv.VirtualMachineSpec)
 }
 func (r *Builder) mapCPU(vm *model.Workload, object *cnv.VirtualMachineSpec) {
 	object.Template.Spec.Domain.Machine = &cnv.Machine{Type: "q35"}
-	object.Template.Spec.Domain.CPU = &cnv.CPU{
-		Sockets: uint32(vm.CpuSockets),
-		Cores:   uint32(vm.CpuCores),
-		Threads: uint32(vm.CpuThreads),
-	}
 	if vm.CpuPinningPolicy == model.Dedicated {
 		object.Template.Spec.Domain.CPU.DedicatedCPUPlacement = true
 	}
@@ -384,6 +382,14 @@ func (r *Builder) mapCPU(vm *model.Workload, object *cnv.VirtualMachineSpec) {
 	} else if r.Plan.Spec.PreserveClusterCPUModel {
 		r.setCpuFlags(r.getClusterCpu(vm), object)
 	}
+	if object.Instancetype != nil {
+		return
+	}
+	object.Template.Spec.Domain.CPU = &cnv.CPU{
+		Sockets: uint32(vm.CpuSockets),
+		Cores:   uint32(vm.CpuCores),
+		Threads: uint32(vm.CpuThreads),
+	}
 }
 
 func (r *Builder) getClusterCpu(vm *model.Workload) string {

diff --git a/pkg/controller/plan/adapter/vsphere/builder.go b/pkg/controller/plan/adapter/vsphere/builder.go
@@ -557,6 +557,9 @@ func (r *Builder) mapClock(host *model.Host, object *cnv.VirtualMachineSpec) {
 }
 
 func (r *Builder) mapMemory(vm *model.VM, object *cnv.VirtualMachineSpec) {
+	if object.Instancetype != nil {
+		return
+	}
 	memoryBytes := int64(vm.MemoryMB) * 1024 * 1024
 	reservation := resource.NewQuantity(memoryBytes, resource.BinarySI)
 	object.Template.Spec.Domain.Resources = cnv.ResourceRequirements{
@@ -568,6 +571,9 @@ func (r *Builder) mapMemory(vm *model.VM, object *cnv.VirtualMachineSpec) {
 
 func (r *Builder) mapCPU(vm *model.VM, object *cnv.VirtualMachineSpec) {
 	object.Template.Spec.Domain.Machine = &cnv.Machine{Type: "q35"}
+	if object.Instancetype != nil {
+		return
+	}
 	object.Template.Spec.Domain.CPU = &cnv.CPU{
 		Sockets: uint32(vm.CpuCount / vm.CoresPerSocket),
 		Cores:   uint32(vm.CoresPerSocket),

diff --git a/pkg/controller/plan/kubevirt.go b/pkg/controller/plan/kubevirt.go
@@ -1232,6 +1232,11 @@ func (r *KubeVirt) virtualMachine(vm *plan.VMStatus) (object *cnv.VirtualMachine
 		}
 	}
 
+	object, err = r.setIntanceType(vm, object)
+	if err != nil {
+		return
+	}
+
 	if object.Spec.Template.ObjectMeta.Labels == nil {
 		object.Spec.Template.ObjectMeta.Labels = map[string]string{}
 	}
@@ -1279,6 +1284,67 @@ func (r *KubeVirt) vmPreference(vm *plan.VMStatus) (virtualMachine *cnv.VirtualM
 	return
 }
 
+func (r *KubeVirt) setIntanceType(vm *plan.VMStatus, object *cnv.VirtualMachine) (virtualMachine *cnv.VirtualMachine, err error) {
+	if r.Plan.Spec.SelectedInstanceType == "" {
+		return object, nil
+	}
+	intancetypeName, kind, err := r.getInstancetype(vm, r.Plan.Spec.SelectedInstanceType)
+	if err != nil {
+		return
+	}
+	object.Spec.Instancetype = &cnv.InstancetypeMatcher{Name: intancetypeName, Kind: kind}
+	virtualMachine = object
+	return
+}
+
+// Attempt to find a suitable instance type
+func (r *KubeVirt) getInstancetype(vm *plan.VMStatus, instancetypeName string) (name, kind string, err error) {
+	name, kind, err = r.getVirtualMachineInstancetype(instancetypeName)
+	if err != nil {
+		if k8serr.IsNotFound(err) {
+			r.Log.Info("could not find a local instance type for destination VM. trying cluster wide",
+				"vm",
+				vm.String())
+		} else {
+			return
+		}
+	}
+
+	name, kind, err = r.getVirtualMachineClusterInstancetype(vm, instancetypeName)
+	return
+}
+
+func (r *KubeVirt) getVirtualMachineInstancetype(instancetypeName string) (name, kind string, err error) {
+	virtualMachineClusterInstancetype := &instancetype.VirtualMachineInstancetype{}
+	err = r.Destination.Client.Get(
+		context.TODO(),
+		client.ObjectKey{Name: instancetypeName, Namespace: r.Plan.Spec.TargetNamespace},
+		virtualMachineClusterInstancetype)
+	if err != nil {
+		return
+	}
+	return instancetypeName, "VirtualMachineInstancetype", nil
+}
+
+func (r *KubeVirt) getVirtualMachineClusterInstancetype(vm *plan.VMStatus, instancetypeName string) (name, kind string, err error) {
+	virtualMachineClusterInstancetype := &instancetype.VirtualMachineClusterInstancetype{}
+	err = r.Destination.Client.Get(
+		context.TODO(),
+		client.ObjectKey{Name: instancetypeName},
+		virtualMachineClusterInstancetype)
+	if err != nil {
+		if k8serr.IsNotFound(err) {
+			r.Log.Info("could not find instance type for destination VM.",
+				"vm",
+				vm.String(),
+				"error",
+				err)
+		}
+		return
+	}
+	return instancetypeName, "VirtualMachineClusterInstancetype", nil
+}
+
 func (r *KubeVirt) getOsMapConfig(providerType v1beta1.ProviderType) (configMap *core.ConfigMap, err error) {
 	configMap = &core.ConfigMap{}
 	var configMapName string