fix(cvi,vi): unlock pending vi/cvi from vd ref

api/core/v1alpha2/cvicondition/condition.go

@@ -44,6 +44,8 @@ const (
 	ClusterImageNotReady DatasourceReadyReason = "ClusterImageNotReady"
 	// VirtualDiskNotReady indicates that the `VirtualDisk` datasource is not ready, which prevents the import process from starting.
 	VirtualDiskNotReady DatasourceReadyReason = "VirtualDiskNotReady"
+	// VirtualDiskInUseInRunningVirtualMachine indicates that the `VirtualDisk` attached to running `VirtualMachine`
+	VirtualDiskInUseInRunningVirtualMachine DatasourceReadyReason = "VirtualDiskInUseInRunningVirtualMachine"
 
 	// WaitForUserUpload indicates that the `ClusterVirtualImage` is waiting for the user to upload a datasource for the import process to continue.
 	WaitForUserUpload ReadyReason = "WaitForUserUpload"

api/core/v1alpha2/vdcondition/condition.go

@@ -28,6 +28,8 @@ const (
 	ResizedType Type = "Resized"
 	// SnapshottingType indicates whether the disk snapshotting operation is in progress.
 	SnapshottingType Type = "Snapshotting"
+	// InUseType indicates whether the VirtualDisk is attached to a running VirtualMachine or is being used in a process of a VirtualImage creation
+	InUseType Type = "InUse"
 )
 
 type (
@@ -39,6 +41,8 @@ type (
 	ResizedReason = string
 	// SnapshottingReason represents the various reasons for the Snapshotting condition type.
 	SnapshottingReason = string
+	// InUseReason represents the various reasons for the InUse condition type.
+	InUseReason = string
 )
 
 const (
@@ -83,4 +87,11 @@ const (
 	Snapshotting SnapshottingReason = "Snapshotting"
 	// SnapshottingNotAvailable indicates that the snapshotting operation is not available for now.
 	SnapshottingNotAvailable SnapshottingReason = "NotAvailable"
+
+	// InUseInRunningVirtualMachine indicates that this `VirtualDisk` attached to running `VirtualMachine`
+	InUseInRunningVirtualMachine InUseReason = "InUseInRunningVirtualMachine"
+	// InUseForCreateImage indicates running a process to create a `VirtualImage` or `ClusterVirtualImage` from this `VirtualDisk`
+	InUseForCreateImage InUseReason = "InUseForCreateImage"
+	// NotInUse indicates that this `VirtualDisk` is available.
+	NotInUse InUseReason = "NotInUse"
 )

api/core/v1alpha2/vicondition/condition.go

@@ -44,6 +44,8 @@ const (
 	ClusterImageNotReady DatasourceReadyReason = "ClusterImageNotReady"
 	// VirtualDiskNotReady indicates that the `VirtualDisk` datasource is not ready, which prevents the import process from starting.
 	VirtualDiskNotReady DatasourceReadyReason = "VirtualDiskNotReady"
+	// VirtualDiskInUseInRunningVirtualMachine indicates that the `VirtualDisk` attached to running `VirtualMachine`
+	VirtualDiskInUseInRunningVirtualMachine DatasourceReadyReason = "VirtualDiskInUseInRunningVirtualMachine"
 
 	// WaitForUserUpload indicates that the `VirtualImage` is waiting for the user to upload a datasource for the import process to continue.
 	WaitForUserUpload ReadyReason = "WaitForUserUpload"

images/virtualization-artifact/pkg/controller/cvi/cvi_reconciler.go

@@ -38,6 +38,7 @@ import (
 	"github.com/deckhouse/virtualization-controller/pkg/controller/watchers"
 	"github.com/deckhouse/virtualization-controller/pkg/logger"
 	virtv2 "github.com/deckhouse/virtualization/api/core/v1alpha2"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/vdcondition"
 )
 
 type Handler interface {
@@ -165,7 +166,14 @@ func (r *Reconciler) SetupController(_ context.Context, mgr manager.Manager, ctr
 					return false
 				}
 
-				return oldVD.Status.Phase != newVD.Status.Phase
+				oldInUseCondition, _ := service.GetCondition(vdcondition.InUseType, oldVD.Status.Conditions)
+				newInUseCondition, _ := service.GetCondition(vdcondition.InUseType, newVD.Status.Conditions)
+
+				if oldVD.Status.Phase != newVD.Status.Phase || len(oldVD.Status.AttachedToVirtualMachines) != len(newVD.Status.AttachedToVirtualMachines) || oldInUseCondition.Status != newInUseCondition.Status {
+					return true
+				}
+
+				return false
 			},
 		},
 	); err != nil {

images/virtualization-artifact/pkg/controller/cvi/internal/datasource_ready.go

@@ -89,9 +89,9 @@ func (h DatasourceReadyHandler) Handle(ctx context.Context, cvi *virtv2.ClusterV
 		condition.Reason = cvicondition.VirtualDiskNotReady
 		condition.Message = service.CapitalizeFirstLetter(err.Error())
 		return reconcile.Result{}, nil
-	case errors.As(err, &source.VirtualDiskAttachedToRunningVMError{}):
+	case errors.As(err, &source.VirtualDiskInUseError{}):
 		condition.Status = metav1.ConditionFalse
-		condition.Reason = cvicondition.VirtualDiskNotReady
+		condition.Reason = cvicondition.VirtualDiskInUseInRunningVirtualMachine
 		condition.Message = service.CapitalizeFirstLetter(err.Error())
 		return reconcile.Result{}, nil
 	default:

images/virtualization-artifact/pkg/controller/cvi/internal/source/errors.go

@@ -65,18 +65,16 @@ func NewVirtualDiskNotReadyError(name string) error {
 	}
 }
 
-type VirtualDiskAttachedToRunningVMError struct {
-	name   string
-	vmName string
+type VirtualDiskInUseError struct {
+	name string
 }
 
-func (e VirtualDiskAttachedToRunningVMError) Error() string {
-	return fmt.Sprintf("VirtualDisk %q attached to running VirtualMachine %q", e.name, e.vmName)
+func (e VirtualDiskInUseError) Error() string {
+	return fmt.Sprintf("VirtualDisk %q attached to running `VirtualMachine`", e.name)
 }
 
-func NewVirtualDiskAttachedToRunningVMError(name, vmName string) error {
-	return VirtualDiskAttachedToRunningVMError{
-		name:   name,
-		vmName: vmName,
+func NewVirtualDiskInUseError(name string) error {
+	return VirtualDiskInUseError{
+		name: name,
 	}
 }

images/virtualization-artifact/pkg/controller/cvi/internal/source/object_ref_vd.go

@@ -34,6 +34,7 @@ import (
 	"github.com/deckhouse/virtualization-controller/pkg/logger"
 	"github.com/deckhouse/virtualization-controller/pkg/sdk/framework/helper"
 	virtv2 "github.com/deckhouse/virtualization/api/core/v1alpha2"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/vdcondition"
 	"github.com/deckhouse/virtualization/api/core/v1alpha2/vicondition"
 )
 
@@ -207,16 +208,10 @@ func (ds ObjectRefVirtualDisk) Validate(ctx context.Context, cvi *virtv2.Cluster
 		return NewVirtualDiskNotReadyError(cvi.Spec.DataSource.ObjectRef.Name)
 	}
 
-	if len(vd.Status.AttachedToVirtualMachines) != 0 {
-		vmName := vd.Status.AttachedToVirtualMachines[0]
-
-		vm, err := helper.FetchObject(ctx, types.NamespacedName{Name: vmName.Name, Namespace: vd.Namespace}, ds.client, &virtv2.VirtualMachine{})
-		if err != nil {
-			return err
-		}
-
-		if vm.Status.Phase != virtv2.MachineStopped {
-			return NewVirtualDiskAttachedToRunningVMError(vd.Name, vmName.Name)
+	inUseCondition, _ := service.GetCondition(vdcondition.InUseType, vd.Status.Conditions)
+	if inUseCondition.Status != metav1.ConditionFalse {
+		if inUseCondition.Reason == vdcondition.InUseInRunningVirtualMachine {
+			return NewVirtualDiskInUseError(vd.Name)
 		}
 	}
 

images/virtualization-artifact/pkg/controller/vd/internal/inuse.go

@@ -0,0 +1,153 @@
+/*
+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"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	virtv1 "kubevirt.io/api/core/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+
+	"github.com/deckhouse/virtualization-controller/pkg/controller/service"
+	"github.com/deckhouse/virtualization-controller/pkg/sdk/framework/helper"
+	virtv2 "github.com/deckhouse/virtualization/api/core/v1alpha2"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/cvicondition"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/vdcondition"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/vicondition"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/vmcondition"
+)
+
+type InUseHandler struct {
+	client client.Client
+}
+
+func NewInUseHandler(client client.Client) *InUseHandler {
+	return &InUseHandler{
+		client: client,
+	}
+}
+
+func (h InUseHandler) Handle(ctx context.Context, vd *virtv2.VirtualDisk) (reconcile.Result, error) {
+	inUseCondition, ok := service.GetCondition(vdcondition.InUseType, vd.Status.Conditions)
+	if !ok {
+		inUseCondition = metav1.Condition{
+			Type:   vdcondition.InUseType,
+			Status: metav1.ConditionUnknown,
+		}
+
+		service.SetCondition(inUseCondition, &vd.Status.Conditions)
+	}
+
+	var inUseForCreateImage, inUseInRunningVirtualMachine bool
+
+	var vms virtv2.VirtualMachineList
+	err := h.client.List(ctx, &vms, &client.ListOptions{
+		Namespace: vd.GetNamespace(),
+	})
+	if err != nil {
+		return reconcile.Result{}, fmt.Errorf("error getting virtual machines: %w", err)
+	}
+
+	for _, vm := range vms.Items {
+		for _, bda := range vm.Status.BlockDeviceRefs {
+			if bda.Kind == virtv2.DiskDevice && bda.Name == vd.GetName() {
+				runningCondition, _ := service.GetCondition(vmcondition.TypeRunning.String(), vm.Status.Conditions)
+				if runningCondition.Status == metav1.ConditionTrue || vm.Status.Phase == virtv2.MachineStarting {
+					inUseInRunningVirtualMachine = true
+				} else {
+					kvvm, err := helper.FetchObject(ctx, types.NamespacedName{Namespace: vm.GetNamespace(), Name: vm.GetName()}, h.client, &virtv1.VirtualMachine{})
+					if err != nil {
+						return reconcile.Result{}, fmt.Errorf("error getting kubevirt virtual machine: %w", err)
+					}
+					if kvvm != nil {
+						if kvvm.Status.StateChangeRequests != nil {
+							inUseInRunningVirtualMachine = true
+						}
+					}
+				}
+			}
+		}
+	}
+
+	var viList virtv2.VirtualImageList
+	err = h.client.List(ctx, &viList, &client.ListOptions{
+		Namespace: vd.GetNamespace(),
+	})
+	if err != nil {
+		return reconcile.Result{}, fmt.Errorf("error getting virtual images: %w", err)
+	}
+
+	for _, vi := range viList.Items {
+		if vi.Spec.DataSource.Type != virtv2.DataSourceTypeObjectRef || vi.Spec.DataSource.ObjectRef == nil {
+			continue
+		}
+
+		if vi.Spec.DataSource.ObjectRef.Kind != virtv2.VirtualDiskKind || vi.Spec.DataSource.ObjectRef.Name != vd.GetName() {
+			continue
+		}
+
+		readyCondition, _ := service.GetCondition(vicondition.ReadyType, vi.Status.Conditions)
+		if readyCondition.Status != metav1.ConditionTrue {
+			inUseForCreateImage = true
+		}
+	}
+
+	var cviList virtv2.ClusterVirtualImageList
+	err = h.client.List(ctx, &cviList, &client.ListOptions{})
+	if err != nil {
+		return reconcile.Result{}, fmt.Errorf("error getting cluster virtual images: %w", err)
+	}
+
+	for _, cvi := range cviList.Items {
+		if cvi.Spec.DataSource.Type != virtv2.DataSourceTypeObjectRef || cvi.Spec.DataSource.ObjectRef == nil {
+			continue
+		}
+
+		if cvi.Spec.DataSource.ObjectRef.Kind != virtv2.VirtualDiskKind || cvi.Spec.DataSource.ObjectRef.Name != vd.GetName() && cvi.Spec.DataSource.ObjectRef.Namespace != vd.GetNamespace() {
+			continue
+		}
+
+		readyCondition, _ := service.GetCondition(cvicondition.ReadyType, cvi.Status.Conditions)
+		if readyCondition.Status != metav1.ConditionTrue {
+			inUseForCreateImage = true
+		}
+	}
+
+	if inUseInRunningVirtualMachine && !inUseForCreateImage {
+		inUseCondition.Status = metav1.ConditionTrue
+		inUseCondition.Reason = vdcondition.InUseInRunningVirtualMachine
+	}
+
+	if inUseForCreateImage && !inUseInRunningVirtualMachine {
+		inUseCondition.Status = metav1.ConditionTrue
+		inUseCondition.Reason = vdcondition.InUseForCreateImage
+	}
+
+	if !inUseInRunningVirtualMachine && !inUseForCreateImage {
+		inUseCondition.Status = metav1.ConditionFalse
+		inUseCondition.Reason = vdcondition.NotInUse
+	}
+
+	inUseCondition.Message = ""
+	service.SetCondition(inUseCondition, &vd.Status.Conditions)
+
+	return reconcile.Result{}, nil
+}

images/virtualization-artifact/pkg/controller/vd/internal/watcher/cvi_watcher.go

@@ -0,0 +1,93 @@
+/*
+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 watcher
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/controller"
+	"sigs.k8s.io/controller-runtime/pkg/event"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"sigs.k8s.io/controller-runtime/pkg/source"
+
+	virtv2 "github.com/deckhouse/virtualization/api/core/v1alpha2"
+)
+
+type ClusterVirtualImageWatcher struct {
+	logger *slog.Logger
+}
+
+func NewClusterVirtualImageWatcher() *ClusterVirtualImageWatcher {
+	return &ClusterVirtualImageWatcher{
+		logger: slog.Default().With("watcher", strings.ToLower(virtv2.ClusterVirtualImageKind)),
+	}
+}
+
+func (w ClusterVirtualImageWatcher) Watch(mgr manager.Manager, ctr controller.Controller) error {
+	return ctr.Watch(
+		source.Kind(mgr.GetCache(), &virtv2.ClusterVirtualImage{}),
+		handler.EnqueueRequestsFromMapFunc(w.enqueueRequests),
+		predicate.Funcs{
+			CreateFunc: func(e event.CreateEvent) bool { return true },
+			DeleteFunc: func(e event.DeleteEvent) bool { return true },
+			UpdateFunc: w.filterUpdateEvents,
+		},
+	)
+}
+
+func (w ClusterVirtualImageWatcher) enqueueRequests(_ context.Context, obj client.Object) (requests []reconcile.Request) {
+	cvi, ok := obj.(*virtv2.ClusterVirtualImage)
+	if !ok {
+		w.logger.Error(fmt.Sprintf("expected a ClusterVirtualImage but got a %T", obj))
+		return
+	}
+
+	if cvi.Spec.DataSource.Type == virtv2.DataSourceTypeObjectRef && cvi.Spec.DataSource.ObjectRef != nil && cvi.Spec.DataSource.ObjectRef.Kind == virtv2.VirtualDiskKind {
+		requests = append(requests, reconcile.Request{
+			NamespacedName: types.NamespacedName{
+				Name:      cvi.Spec.DataSource.ObjectRef.Name,
+				Namespace: cvi.Spec.DataSource.ObjectRef.Namespace,
+			},
+		})
+	}
+
+	return
+}
+
+func (w ClusterVirtualImageWatcher) filterUpdateEvents(e event.UpdateEvent) bool {
+	oldCVI, ok := e.ObjectOld.(*virtv2.ClusterVirtualImage)
+	if !ok {
+		w.logger.Error(fmt.Sprintf("expected an old ClusterVirtualImage but got a %T", e.ObjectOld))
+		return false
+	}
+
+	newCVI, ok := e.ObjectNew.(*virtv2.ClusterVirtualImage)
+	if !ok {
+		w.logger.Error(fmt.Sprintf("expected a new ClusterVirtualImage but got a %T", e.ObjectNew))
+		return false
+	}
+
+	return oldCVI.Status.Phase != newCVI.Status.Phase
+}