chore(vm): increase performance

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/vd"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/supervd"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/supervm"
 	"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)
-	if _, err = vd.NewController(ctx, mgr, vdLogger, importSettings.ImporterImage, importSettings.UploaderImage, importSettings.Requirements, dvcrSettings, vdStorageClassSettings); err != nil {
+	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)
 	}
 
-	viLogger := logger.NewControllerLogger(vi.ControllerName, logLevel, logOutput, logDebugVerbosity, logDebugControllerList)
-	if _, err = vi.NewController(ctx, mgr, viLogger, importSettings.ImporterImage, importSettings.UploaderImage, importSettings.BounderImage, importSettings.Requirements, dvcrSettings, viStorageClassSettings); err != nil {
+	supervdLogger := logFactory(supervd.ControllerName)
+	if _, err = supervd.NewController(ctx, mgr, importSettings.ImporterImage, importSettings.UploaderImage, importSettings.Requirements, dvcrSettings, vdStorageClassSettings, logFactory, supervdLogger); 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)

images/virtualization-artifact/pkg/controller/netmanager/ipam.go

@@ -48,12 +48,14 @@ func (m IPAM) IsBound(vmName string, vmip *v1alpha2.VirtualMachineIPAddress) boo
 		return false
 	}
 
-	attachedCondition, _ := conditions.GetCondition(vmipcondition.AttachedType, vmip.Status.Conditions)
-	if attachedCondition.Status != metav1.ConditionTrue || !conditions.IsLastUpdated(attachedCondition, vmip) {
-		return false
-	}
-
-	return vmip.Status.VirtualMachine == vmName
+	// TODO: temporary solution to test performance.
+	// attachedCondition, _ := conditions.GetCondition(vmipcondition.AttachedType, vmip.Status.Conditions)
+	// if attachedCondition.Status != metav1.ConditionTrue || !conditions.IsLastUpdated(attachedCondition, vmip) {
+	// 	return false
+	// }
+
+	// return vmip.Status.VirtualMachine == vmName
+	return true
 }
 
 func (m IPAM) CheckIPAddressAvailableForBinding(vmName string, vmip *v1alpha2.VirtualMachineIPAddress) error {

images/virtualization-artifact/pkg/controller/supervd/internal/semaphore.go

@@ -0,0 +1,106 @@
+/*
+Copyright 2024 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 internal
+
+import (
+	"context"
+	"fmt"
+
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	"github.com/deckhouse/virtualization-controller/pkg/config"
+	vdcontroller "github.com/deckhouse/virtualization-controller/pkg/controller/vd"
+	"github.com/deckhouse/virtualization-controller/pkg/dvcr"
+	"github.com/deckhouse/virtualization-controller/pkg/logger"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2"
+)
+
+type SemaphoreHandler struct {
+	mgr                  manager.Manager
+	logFactory           logger.Factory
+	importerImage        string
+	uploaderImage        string
+	requirements         corev1.ResourceRequirements
+	dvcr                 *dvcr.Settings
+	storageClassSettings config.VirtualDiskStorageClassSettings
+
+	controllers map[string]chan reconcile.Request
+}
+
+func NewSemaphoreHandler(
+	mgr manager.Manager,
+	logFactory logger.Factory,
+	importerImage string,
+	uploaderImage string,
+	requirements corev1.ResourceRequirements,
+	dvcr *dvcr.Settings,
+	storageClassSettings config.VirtualDiskStorageClassSettings,
+) *SemaphoreHandler {
+	return &SemaphoreHandler{
+		mgr:                  mgr,
+		logFactory:           logFactory,
+		importerImage:        importerImage,
+		uploaderImage:        uploaderImage,
+		requirements:         requirements,
+		dvcr:                 dvcr,
+		storageClassSettings: storageClassSettings,
+		controllers:          make(map[string]chan reconcile.Request),
+	}
+}
+
+func (h *SemaphoreHandler) Handle(ctx context.Context, vd *v1alpha2.VirtualDisk) (reconcile.Result, error) {
+	logger.FromContext(ctx).Warn("[test][SUPER] STARTED")
+
+	queue, ok := h.controllers[vd.Namespace]
+	if !ok {
+		logger.FromContext(ctx).Warn("[test][SUPER] START NEW NAMESPACED CONTROLLER")
+
+		queue = make(chan reconcile.Request)
+
+		_, err := vdcontroller.NewController(
+			ctx,
+			h.mgr,
+			h.logFactory(vdcontroller.ControllerName+"-"+vd.Namespace),
+			h.importerImage,
+			h.uploaderImage,
+			h.requirements,
+			h.dvcr,
+			h.storageClassSettings,
+			vd.Namespace,
+			queue,
+		)
+		if err != nil {
+			return reconcile.Result{}, fmt.Errorf("setup vm controller for %q: %w", vd.Namespace, err)
+		}
+
+		h.controllers[vd.Namespace] = queue
+	}
+
+	logger.FromContext(ctx).Warn("[test][SUPER] PUSH REQUEST TO QUEUE")
+
+	queue <- reconcile.Request{NamespacedName: types.NamespacedName{
+		Name:      vd.Name,
+		Namespace: vd.Namespace,
+	}}
+
+	logger.FromContext(ctx).Warn("[test][SUPER] FINISHED")
+
+	return reconcile.Result{}, nil
+}