chore(vm): increase performance

Signed-off-by: Isteb4k <dmitry.rakitin@flant.com>

Author: Isteb4k

images/virtualization-artifact/cmd/virtualization-controller/main.go

@@ -46,10 +46,10 @@ import (
 	"github.com/deckhouse/virtualization-controller/pkg/controller/livemigration"
 	mc "github.com/deckhouse/virtualization-controller/pkg/controller/moduleconfig"
 	mcapi "github.com/deckhouse/virtualization-controller/pkg/controller/moduleconfig/api"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/supervm"
 	"github.com/deckhouse/virtualization-controller/pkg/controller/vd"
 	"github.com/deckhouse/virtualization-controller/pkg/controller/vdsnapshot"
 	"github.com/deckhouse/virtualization-controller/pkg/controller/vi"
-	"github.com/deckhouse/virtualization-controller/pkg/controller/vm"
 	"github.com/deckhouse/virtualization-controller/pkg/controller/vmbda"
 	"github.com/deckhouse/virtualization-controller/pkg/controller/vmclass"
 	"github.com/deckhouse/virtualization-controller/pkg/controller/vmip"
@@ -313,77 +313,79 @@ func main() {
 		os.Exit(1)
 	}
 
-	cviLogger := logger.NewControllerLogger(cvi.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	logFactory := logger.NewFactory(logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+
+	cviLogger := logFactory(cvi.ControllerName)
 	if _, err = cvi.NewController(ctx, mgr, cviLogger, importSettings.ImporterImage, importSettings.UploaderImage, importSettings.Requirements, dvcrSettings, controllerNamespace); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vdLogger := logger.NewControllerLogger(vd.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vdLogger := logFactory(vd.ControllerName)
 	if _, err = vd.NewController(ctx, mgr, vdLogger, importSettings.ImporterImage, importSettings.UploaderImage, importSettings.Requirements, dvcrSettings, vdStorageClassSettings); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	viLogger := logger.NewControllerLogger(vi.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	viLogger := logFactory(vi.ControllerName)
 	if _, err = vi.NewController(ctx, mgr, viLogger, importSettings.ImporterImage, importSettings.UploaderImage, importSettings.BounderImage, importSettings.Requirements, dvcrSettings, viStorageClassSettings); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmLogger := logger.NewControllerLogger(vm.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
-	if err = vm.SetupController(ctx, mgr, vmLogger, dvcrSettings, firmwareImage); err != nil {
+	supervmLogger := logFactory(supervm.ControllerName)
+	if err = supervm.SetupController(ctx, mgr, dvcrSettings, firmwareImage, logFactory, supervmLogger); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
-	if err = vm.SetupGC(mgr, vmLogger, gcSettings.VMIMigration); err != nil {
+	if err = supervm.SetupGC(mgr, supervmLogger, gcSettings.VMIMigration); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmbdaLogger := logger.NewControllerLogger(vmbda.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vmbdaLogger := logFactory(vmbda.ControllerName)
 	if _, err = vmbda.NewController(ctx, mgr, virtClient, vmbdaLogger, controllerNamespace); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmipLogger := logger.NewControllerLogger(vmip.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vmipLogger := logFactory(vmip.ControllerName)
 	if _, err = vmip.NewController(ctx, mgr, virtClient, vmipLogger, virtualMachineCIDRs); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmipleaseLogger := logger.NewControllerLogger(vmiplease.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vmipleaseLogger := logFactory(vmiplease.ControllerName)
 	if _, err = vmiplease.NewController(ctx, mgr, vmipleaseLogger, virtualMachineIPLeasesRetentionDuration); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmclassLogger := logger.NewControllerLogger(vmclass.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vmclassLogger := logFactory(vmclass.ControllerName)
 	if _, err = vmclass.NewController(ctx, mgr, controllerNamespace, vmclassLogger); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vdsnapshotLogger := logger.NewControllerLogger(vdsnapshot.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vdsnapshotLogger := logFactory(vdsnapshot.ControllerName)
 	if _, err = vdsnapshot.NewController(ctx, mgr, vdsnapshotLogger, virtClient); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmsnapshotLogger := logger.NewControllerLogger(vmsnapshot.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vmsnapshotLogger := logFactory(vmsnapshot.ControllerName)
 	if err = vmsnapshot.NewController(ctx, mgr, vmsnapshotLogger, virtClient); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmrestoreLogger := logger.NewControllerLogger(vmrestore.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vmrestoreLogger := logFactory(vmrestore.ControllerName)
 	if err = vmrestore.NewController(ctx, mgr, vmrestoreLogger); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmopLogger := logger.NewControllerLogger(vmop.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vmopLogger := logFactory(vmop.ControllerName)
 	if err = vmop.SetupController(ctx, mgr, vmopLogger); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
@@ -393,7 +395,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	liveMigrationLogger := logger.NewControllerLogger(livemigration.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	liveMigrationLogger := logFactory(livemigration.ControllerName)
 	if err = livemigration.SetupController(ctx, mgr, liveMigrationLogger); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
@@ -404,31 +406,31 @@ func main() {
 		os.Exit(1)
 	}
 
-	workloadUpdaterLogger := logger.NewControllerLogger(workloadupdater.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	workloadUpdaterLogger := logFactory(workloadupdater.ControllerName)
 	if err = workloadupdater.SetupController(ctx, mgr, workloadUpdaterLogger, firmwareImage, controllerNamespace, virtControllerName); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	evacuationLogger := logger.NewControllerLogger(evacuation.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	evacuationLogger := logFactory(evacuation.ControllerName)
 	if err = evacuation.SetupController(ctx, mgr, virtClient, evacuationLogger); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	volumeMigrationLogger := logger.NewControllerLogger(volumemigration.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	volumeMigrationLogger := logFactory(volumemigration.ControllerName)
 	if err = volumemigration.SetupController(ctx, mgr, volumeMigrationLogger); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmmacLogger := logger.NewControllerLogger(vmmac.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vmmacLogger := logFactory(vmmac.ControllerName)
 	if _, err = vmmac.NewController(ctx, mgr, vmmacLogger, clusterUUID, virtClient); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)
 	}
 
-	vmmacleaseLogger := logger.NewControllerLogger(vmmaclease.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
+	vmmacleaseLogger := logFactory(vmmaclease.ControllerName)
 	if _, err = vmmaclease.NewController(ctx, mgr, vmmacleaseLogger); err != nil {
 		log.Error(err.Error())
 		os.Exit(1)

…ization-artifact/pkg/controller/vm/gc.go …on-artifact/pkg/controller/supervm/gc.goimages/virtualization-artifact/pkg/controller/vm/gc.go renamed to images/virtualization-artifact/pkg/controller/supervm/gc.go images/virtualization-artifact/pkg/controller/vm/gc.go renamed to images/virtualization-artifact/pkg/controller/supervm/gc.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package vm
+package supervm
 
 import (
 	"context"

images/virtualization-artifact/pkg/controller/supervm/internal/defaulter/defaulters_suite_test.go

@@ -0,0 +1,158 @@
+/*
+Copyright 2025 Flant JSC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package defaulter_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/deckhouse/virtualization-controller/pkg/common/annotations"
+	"github.com/deckhouse/virtualization-controller/pkg/common/testutil"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/service"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/supervm/internal/defaulter"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2"
+)
+
+func TestDefaulters(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "VM Defaulters Suite")
+}
+
+var _ = Describe("Set default class in virtualMachineClasName", func() {
+	var (
+		ctx            = testutil.ContextBackgroundWithNoOpLogger()
+		classDefaulter *defaulter.VirtualMachineClassNameDefaulter
+	)
+
+	setup := func(objs ...client.Object) {
+		GinkgoHelper()
+		fakeClient, err := testutil.NewFakeClientWithObjects(objs...)
+		Expect(err).Should(BeNil())
+		vmClassService := service.NewVirtualMachineClassService(fakeClient)
+		classDefaulter = defaulter.NewVirtualMachineClassNameDefaulter(fakeClient, vmClassService)
+	}
+
+	newVMClass := func(name string) *v1alpha2.VirtualMachineClass {
+		return &v1alpha2.VirtualMachineClass{
+			TypeMeta: metav1.TypeMeta{
+				Kind:       v1alpha2.VirtualMachineClassKind,
+				APIVersion: v1alpha2.SchemeGroupVersion.String(),
+			},
+			ObjectMeta: metav1.ObjectMeta{
+				Name: name,
+			},
+			Spec:   v1alpha2.VirtualMachineClassSpec{},
+			Status: v1alpha2.VirtualMachineClassStatus{},
+		}
+	}
+
+	newDefaultVMClass := func(name string) *v1alpha2.VirtualMachineClass {
+		vmClass := newVMClass(name)
+		vmClass.Annotations = map[string]string{
+			annotations.AnnVirtualMachineClassDefault: "true",
+		}
+		return vmClass
+	}
+
+	newVMWithEmptyClass := func(name string) *v1alpha2.VirtualMachine {
+		return &v1alpha2.VirtualMachine{
+			TypeMeta: metav1.TypeMeta{
+				Kind:       v1alpha2.VirtualMachineKind,
+				APIVersion: v1alpha2.SchemeGroupVersion.String(),
+			},
+			ObjectMeta: metav1.ObjectMeta{
+				Name: name,
+			},
+			Spec:   v1alpha2.VirtualMachineSpec{},
+			Status: v1alpha2.VirtualMachineStatus{},
+		}
+	}
+
+	newVM := func(name, className string) *v1alpha2.VirtualMachine {
+		vm := newVMWithEmptyClass(name)
+		vm.Spec.VirtualMachineClassName = className
+		return vm
+	}
+
+	AfterEach(func() {
+		classDefaulter = nil
+	})
+
+	Context("creating VM with empty virtualMachineClassName", func() {
+		It("should keep virtualMachineClassName empty if no default class", func() {
+			// Initialize fake client with some classes.
+			name := "single-custom-class"
+			setup(
+				newVMClass("generic"),
+				newVMClass(name),
+			)
+
+			vm := newVMWithEmptyClass("vm-with-empty-class")
+			err := classDefaulter.Default(ctx, vm)
+			Expect(err).Should(BeNil())
+			Expect(vm.Spec.VirtualMachineClassName).Should(BeEmpty())
+		})
+
+		It("should set virtualMachineClassName if default class is present", func() {
+			// Initialize fake client with existing non default class.
+			className := "single-default-class"
+			setup(
+				newVMClass("generic"),
+				newDefaultVMClass(className),
+			)
+
+			vm := newVMWithEmptyClass("vm-with-empty-class")
+			err := classDefaulter.Default(ctx, vm)
+			Expect(err).Should(BeNil())
+			Expect(vm.Spec.VirtualMachineClassName).Should(Equal(className))
+		})
+	})
+
+	Context("creating VM with virtualMachineClassName", func() {
+		It("should not change virtualMachineClassName if no default class", func() {
+			// Initialize fake client with some classes.
+			name := "single-custom-class"
+			setup(
+				newVMClass("generic"),
+				newVMClass(name),
+			)
+
+			vm := newVM("vm-with-empty-class", "generic")
+			err := classDefaulter.Default(ctx, vm)
+			Expect(err).Should(BeNil())
+			Expect(vm.Spec.VirtualMachineClassName).Should(Equal("generic"))
+		})
+
+		It("should not change virtualMachineClassName if default class is present", func() {
+			// Initialize fake client with existing non default class.
+			className := "single-default-class"
+			setup(
+				newVMClass("generic"),
+				newDefaultVMClass(className),
+			)
+
+			vm := newVM("vm-with-empty-class", "generic")
+			err := classDefaulter.Default(ctx, vm)
+			Expect(err).Should(BeNil())
+			Expect(vm.Spec.VirtualMachineClassName).Should(Equal("generic"))
+		})
+	})
+})

images/virtualization-artifact/pkg/controller/supervm/internal/defaulter/virtual_machine_class_name.go

@@ -0,0 +1,67 @@
+/*
+Copyright 2025 Flant JSC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package defaulter
+
+import (
+	"context"
+	"fmt"
+
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/deckhouse/virtualization-controller/pkg/controller/service"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2"
+)
+
+type VirtualMachineClassNameDefaulter struct {
+	client         client.Client
+	vmClassService *service.VirtualMachineClassService
+}
+
+func NewVirtualMachineClassNameDefaulter(client client.Client, vmClassService *service.VirtualMachineClassService) *VirtualMachineClassNameDefaulter {
+	return &VirtualMachineClassNameDefaulter{
+		client:         client,
+		vmClassService: vmClassService,
+	}
+}
+
+func (v *VirtualMachineClassNameDefaulter) Default(ctx context.Context, vm *v1alpha2.VirtualMachine) error {
+	// Ignore if virtualMachineClassName is set.
+	if vm.Spec.VirtualMachineClassName != "" {
+		return nil
+	}
+
+	// Detect and assign default class name.
+	classes := &v1alpha2.VirtualMachineClassList{}
+	err := v.client.List(ctx, classes)
+	if err != nil {
+		return fmt.Errorf("failed to list virtual machine classes: %w", err)
+	}
+
+	defaultClass, err := v.vmClassService.GetDefault(classes)
+	if err != nil {
+		return err
+	}
+
+	// "No default class" is not a mutating error, validators will complain
+	// about missing field during validation phase later.
+	if defaultClass == nil {
+		return nil
+	}
+
+	vm.Spec.VirtualMachineClassName = defaultClass.GetName()
+	return nil
+}