feat: impl inplace resize

api/core/v1alpha2/vmcondition/condition.go

@@ -50,6 +50,8 @@ const (
 	// TypeMaintenance indicates that the VirtualMachine is in maintenance mode.
 	// During this condition, the VM remains stopped and no changes are allowed.
 	TypeMaintenance Type = "Maintenance"
+
+	TypeResizing Type = "Resizing"
 )
 
 type AgentReadyReason string
@@ -283,3 +285,14 @@ func (r MaintenanceReason) String() string {
 const (
 	ReasonMaintenanceRestore MaintenanceReason = "RestoreInProgress"
 )
+
+type ResizingReason string
+
+func (r ResizingReason) String() string {
+	return string(r)
+}
+
+const (
+	ReasonResizingPending    ResizingReason = "Pending"
+	ReasonResizingInProgress ResizingReason = "InProgress"
+)

build/components/versions.yml

@@ -3,7 +3,7 @@ firmware:
   libvirt: v10.9.0
   edk2: stable202411
 core:
-  3p-kubevirt: v1.6.2-v12n.44
+  3p-kubevirt: feat/inplace-resize # v1.6.2-v12n.44
   3p-containerized-data-importer: v1.60.3-v12n.19
   distribution: 2.8.3
 package:

images/virt-artifact/werf.inc.yaml

@@ -9,6 +9,7 @@
 image: {{ .ModuleNamePrefix }}{{ .ImageName }}-src-artifact
 final: false
 fromImage: builder/src
+fromCacheVersion: "015"
 secrets:
 - id: SOURCE_REPO
   value: {{ $.SOURCE_REPO }}

images/virtualization-artifact/pkg/common/annotations/annotations.go

@@ -231,6 +231,9 @@ const (
 	DefaultUSBDeviceGroup = "64535"
 	// DefaultUSBDeviceUser is the default device user ID for USB devices.
 	DefaultUSBDeviceUser = "64535"
+
+	AnnVirtualMachineInstanceInPlaceResizeInProgress = "kubevirt.io/in-place-resize-in-progress"
+	AnnVirtualMachineInstanceDisableInPlaceResize    = "kubevirt.io/disable-in-place-resize"
 )
 
 // AddAnnotation adds an annotation to an object

images/virtualization-artifact/pkg/controller/service/inplaceresize/inplaceresize_service.go

@@ -0,0 +1,75 @@
+package inplaceresize
+
+import (
+	"github.com/deckhouse/virtualization-controller/pkg/featuregates"
+	"github.com/deckhouse/virtualization-controller/pkg/common/annotations"
+	"k8s.io/component-base/featuregate"
+	virtv1 "kubevirt.io/api/core/v1"
+	"context"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/conditions"
+	"fmt"
+	"github.com/deckhouse/virtualization-controller/pkg/common/kvvm"
+	corev1 "k8s.io/api/core/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+func New(featureGates featuregate.FeatureGate, client client.Client) *Service {
+	return &Service{
+		featureGates: featureGates,
+		client:       client,
+	}
+}
+
+type Service struct {
+	featureGates featuregate.FeatureGate
+	client       client.Client
+}
+
+func (s *Service) InProgress(kvvmi *virtv1.VirtualMachineInstance) bool {
+	if s.featureGates.Enabled(featuregates.HotplugCPUInPlaceResize) || s.featureGates.Enabled(featuregates.HotplugMemoryInPlaceResize) {
+		return kvvmi.GetAnnotations()[annotations.AnnVirtualMachineInstanceInPlaceResizeInProgress] == "true"
+	}
+
+	return false
+}
+
+func (s *Service) IsCompleted(kvvmi *virtv1.VirtualMachineInstance) bool {
+	cond, _ := conditions.GetKVVMICondition("PodResourceResizeInProgress", kvvmi.Status.Conditions)
+	return cond.Reason == "PodResizeCompleted"
+}
+
+func (s *Service) IsPossible(ctx context.Context, kvvmi *virtv1.VirtualMachineInstance) (bool, error) {
+	cond, exists := conditions.GetKVVMICondition("PodResourceResizeInProgress", kvvmi.Status.Conditions)
+	if !exists {
+		return false, fmt.Errorf("failed to get PodResourceResizeInProgress condition")
+	}
+
+	switch cond.Reason {
+	case "PodResizeCompleted":
+		return false, nil
+	case "PodResizePending", "PodResizeInProgress":
+	default:
+		return false, fmt.Errorf("unexpected PodResourceResizeInProgress condition reason: %s", cond.Reason)
+	}
+
+	pod, err := kvvm.FindPodByKVVMI(ctx, s.client, kvvmi)
+	if err != nil {
+		return false, err
+	}
+
+	podResizePending, _ := conditions.GetPodCondition(corev1.PodResizePending, pod.Status.Conditions)
+	if podResizePending.Reason == corev1.PodReasonDeferred || podResizePending.Reason == corev1.PodReasonInfeasible {
+		return false, nil
+	}
+	podResizeInProgress, _ := conditions.GetPodCondition(corev1.PodResizeInProgress, pod.Status.Conditions)
+	if podResizeInProgress.Reason == corev1.PodReasonError {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+func (s *Service) ResizeCondition(kvvmi *virtv1.VirtualMachineInstance) virtv1.VirtualMachineInstanceCondition {
+	cond, _ := conditions.GetKVVMICondition("PodResourceResizeInProgress", kvvmi.Status.Conditions)
+	return cond
+}

images/virtualization-artifact/pkg/controller/vm/internal/resizing.go

@@ -0,0 +1,66 @@
+package internal
+
+import (
+	"context"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/vm/internal/state"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/service/inplaceresize"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/conditions"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/vmcondition"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const resizingHandlerName = "ResizingHandler"
+
+type ResizingHandler struct {
+	inplaceResize *inplaceresize.Service
+}
+
+func NewResizingHandler(svc *inplaceresize.Service) *ResizingHandler {
+	return &ResizingHandler{
+		inplaceResize: svc,
+	}
+}
+
+func (h *ResizingHandler) Handle(ctx context.Context, s state.VirtualMachineState) (reconcile.Result, error) {
+	vm := s.VirtualMachine().Changed()
+
+	if isDeletion(vm) {
+		return reconcile.Result{}, nil
+	}
+
+	kvvmi, err := s.KVVMI(ctx)
+	if err != nil {
+		return reconcile.Result{}, err
+	}
+
+	if kvvmi == nil || !h.inplaceResize.InProgress(kvvmi) {
+		conditions.RemoveCondition(vmcondition.TypeResizing, &vm.Status.Conditions)
+		return reconcile.Result{}, nil
+	}
+
+	cb := conditions.NewConditionBuilder(vmcondition.TypeResizing).
+		Generation(vm.GetGeneration()).
+		Status(metav1.ConditionTrue)
+
+	cond := h.inplaceResize.ResizeCondition(kvvmi)
+	switch cond.Reason {
+	case "PodResizePending":
+		cb.Reason(vmcondition.ReasonResizingPending).Message(cond.Message)
+	case "PodResizeInProgress":
+		cb.Reason(vmcondition.ReasonResizingInProgress).Message(cond.Message)
+	case "PodResizeCompleted":
+		cb.Reason(vmcondition.ReasonResizingInProgress).Message("Pod resize completed, waiting when cpu and memory will be hotplugged on virtual machine")
+	default:
+		conditions.RemoveCondition(vmcondition.TypeResizing, &vm.Status.Conditions)
+		return reconcile.Result{}, nil
+	}
+
+	conditions.SetCondition(cb, &vm.Status.Conditions)
+
+	return reconcile.Result{}, nil
+}
+
+func (h *ResizingHandler) Name() string {
+	return resizingHandlerName
+}

images/virtualization-artifact/pkg/controller/vm/internal/resizing_test.go

@@ -0,0 +1,195 @@
+/*
+Copyright 2026 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"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	virtv1 "kubevirt.io/api/core/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	vmbuilder "github.com/deckhouse/virtualization-controller/pkg/builder/vm"
+	"github.com/deckhouse/virtualization-controller/pkg/common/annotations"
+	"github.com/deckhouse/virtualization-controller/pkg/common/testutil"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/conditions"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/reconciler"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/service/inplaceresize"
+	"github.com/deckhouse/virtualization-controller/pkg/controller/vm/internal/state"
+	"github.com/deckhouse/virtualization-controller/pkg/featuregates"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/vmcondition"
+)
+
+var _ = Describe("ResizingHandler", func() {
+	const (
+		name      = "vm-resizing"
+		namespace = "default"
+		nodeName  = "test-node"
+	)
+
+	var (
+		ctx        = testutil.ContextBackgroundWithNoOpLogger()
+		fakeClient client.WithWatch
+		resource   *reconciler.Resource[*v1alpha2.VirtualMachine, v1alpha2.VirtualMachineStatus]
+		vmState    state.VirtualMachineState
+	)
+
+	AfterEach(func() {
+		fakeClient = nil
+		resource = nil
+		vmState = nil
+	})
+
+	newVM := func() *v1alpha2.VirtualMachine {
+		return vmbuilder.NewEmpty(name, namespace)
+	}
+
+	newHandler := func() *ResizingHandler {
+		gate, setFeatureMap, err := featuregates.NewUnlocked()
+		Expect(err).NotTo(HaveOccurred())
+		err = setFeatureMap(map[string]bool{
+			string(featuregates.HotplugCPUInPlaceResize):    true,
+			string(featuregates.HotplugMemoryInPlaceResize): true,
+		})
+		Expect(err).NotTo(HaveOccurred())
+
+		return NewResizingHandler(inplaceresize.New(gate, fakeClient))
+	}
+
+	newResizingKVVMI := func(reason, message string) *virtv1.VirtualMachineInstance {
+		kvvmi := newEmptyKVVMI(name, namespace)
+		kvvmi.UID = types.UID("kvvmi-uid")
+		kvvmi.Annotations = map[string]string{
+			annotations.AnnVirtualMachineInstanceInPlaceResizeInProgress: "true",
+		}
+		kvvmi.Status.NodeName = nodeName
+		kvvmi.Status.Conditions = []virtv1.VirtualMachineInstanceCondition{
+			{
+				Type:    "PodResourceResizeInProgress",
+				Status:  corev1.ConditionTrue,
+				Reason:  reason,
+				Message: message,
+			},
+		}
+
+		if reason != "PodResizeCompleted" {
+			kvvmi.Status.ActivePods = map[types.UID]string{
+				types.UID("virt-launcher-uid"): nodeName,
+			}
+		}
+
+		return kvvmi
+	}
+
+	reconcile := func() error {
+		h := newHandler()
+		_, err := h.Handle(ctx, vmState)
+		if err != nil {
+			return err
+		}
+
+		return resource.Update(context.Background())
+	}
+
+	Describe("Condition presence and absence scenarios", func() {
+		It("Should remove condition when KVVMI is absent", func() {
+			vm := newVM()
+			vm.Status.Conditions = []metav1.Condition{{
+				Type:   vmcondition.TypeResizing.String(),
+				Status: metav1.ConditionTrue,
+			}}
+
+			fakeClient, resource, vmState = setupEnvironment(vm)
+			err := reconcile()
+			Expect(err).NotTo(HaveOccurred())
+
+			actualVM := &v1alpha2.VirtualMachine{}
+			err = fakeClient.Get(ctx, client.ObjectKeyFromObject(vm), actualVM)
+			Expect(err).NotTo(HaveOccurred())
+
+			_, exists := conditions.GetCondition(vmcondition.TypeResizing, actualVM.Status.Conditions)
+			Expect(exists).To(BeFalse())
+		})
+
+		DescribeTable("Should set resizing condition according to resize state",
+			func(reason, message, expectedReason, expectedMessage string) {
+				vm := newVM()
+				kvvmi := newResizingKVVMI(reason, message)
+
+				fakeClient, resource, vmState = setupEnvironment(vm, kvvmi)
+				err := reconcile()
+				Expect(err).NotTo(HaveOccurred())
+
+				actualVM := &v1alpha2.VirtualMachine{}
+				err = fakeClient.Get(ctx, client.ObjectKeyFromObject(vm), actualVM)
+				Expect(err).NotTo(HaveOccurred())
+
+				cond, exists := conditions.GetCondition(vmcondition.TypeResizing, actualVM.Status.Conditions)
+				Expect(exists).To(BeTrue())
+				Expect(cond.Status).To(Equal(metav1.ConditionTrue))
+				Expect(cond.Reason).To(Equal(expectedReason))
+				Expect(cond.Message).To(Equal(expectedMessage))
+			},
+			Entry("pending resize", string(corev1.PodResizePending), "Waiting for kubelet", vmcondition.ReasonResizingPending.String(), "Waiting for kubelet"),
+			Entry("in progress resize", string(corev1.PodResizeInProgress), "Resizing pod resources", vmcondition.ReasonResizingInProgress.String(), "Resizing pod resources"),
+		)
+
+		It("Should keep in-progress reason after pod resize completion", func() {
+			vm := newVM()
+			kvvmi := newResizingKVVMI("PodResizeCompleted", "Completed")
+
+			fakeClient, resource, vmState = setupEnvironment(vm, kvvmi)
+			err := reconcile()
+			Expect(err).NotTo(HaveOccurred())
+
+			actualVM := &v1alpha2.VirtualMachine{}
+			err = fakeClient.Get(ctx, client.ObjectKeyFromObject(vm), actualVM)
+			Expect(err).NotTo(HaveOccurred())
+
+			cond, exists := conditions.GetCondition(vmcondition.TypeResizing, actualVM.Status.Conditions)
+			Expect(exists).To(BeTrue())
+			Expect(cond.Status).To(Equal(metav1.ConditionTrue))
+			Expect(cond.Reason).To(Equal(vmcondition.ReasonResizingInProgress.String()))
+			Expect(cond.Message).To(Equal("Pod resize completed, waiting when cpu and memory will be hotplugged on virtual machine"))
+		})
+	})
+
+	It("Should remove condition when resize reason is unexpected", func() {
+		vm := newVM()
+		vm.Status.Conditions = []metav1.Condition{{
+			Type:   vmcondition.TypeResizing.String(),
+			Status: metav1.ConditionTrue,
+		}}
+		kvvmi := newResizingKVVMI("UnexpectedReason", "unexpected")
+
+		fakeClient, resource, vmState = setupEnvironment(vm, kvvmi)
+		err := reconcile()
+		Expect(err).NotTo(HaveOccurred())
+
+		actualVM := &v1alpha2.VirtualMachine{}
+		err = fakeClient.Get(ctx, client.ObjectKeyFromObject(vm), actualVM)
+		Expect(err).NotTo(HaveOccurred())
+
+		_, exists := conditions.GetCondition(vmcondition.TypeResizing, actualVM.Status.Conditions)
+		Expect(exists).To(BeFalse())
+	})
+})