fix(vmrestore): restore AlwaysOn vm with forced mode

images/virtualization-artifact/pkg/controller/vmrestore/internal/life_cycle.go

@@ -130,13 +130,18 @@ func (h LifeCycleHandler) Handle(ctx context.Context, vmRestore *virtv2.VirtualM
 		return reconcile.Result{}, err
 	}
 
-	var overrideValidators []OverrideValidator
+	var (
+		overrideValidators []OverrideValidator
+		runPolicy          virtv2.RunPolicy
+		overridedVMName    string
+	)
 
 	vm, err := h.restorer.RestoreVirtualMachine(ctx, restorerSecret)
 	if err != nil {
 		setPhaseConditionToFailed(cb, &vmRestore.Status.Phase, err)
 		return reconcile.Result{}, err
 	}
+	runPolicy = vm.Spec.RunPolicy
 
 	vmip, err := h.restorer.RestoreVirtualMachineIPAddress(ctx, restorerSecret)
 	if err != nil {
@@ -151,6 +156,12 @@ func (h LifeCycleHandler) Handle(ctx context.Context, vmRestore *virtv2.VirtualM
 
 	overrideValidators = append(overrideValidators, restorer.NewVirtualMachineOverrideValidator(vm, h.client, string(vmRestore.UID)))
 
+	overridedVMName, err = h.getOverrridedVMName(overrideValidators)
+	if err != nil {
+		setPhaseConditionToFailed(cb, &vmRestore.Status.Phase, err)
+		return reconcile.Result{}, err
+	}
+
 	vds, err := h.getVirtualDisks(ctx, vmSnapshot)
 	switch {
 	case err == nil:
@@ -214,12 +225,6 @@ func (h LifeCycleHandler) Handle(ctx context.Context, vmRestore *virtv2.VirtualM
 			}
 		}
 
-		overridedVMName, err := h.getOverrridedVMName(overrideValidators)
-		if err != nil {
-			setPhaseConditionToFailed(cb, &vmRestore.Status.Phase, err)
-			return reconcile.Result{}, err
-		}
-
 		vmObj, err := object.FetchObject(ctx, types.NamespacedName{Name: overridedVMName, Namespace: vm.Namespace}, h.client, &virtv2.VirtualMachine{})
 		if err != nil {
 			setPhaseConditionToFailed(cb, &vmRestore.Status.Phase, err)
@@ -238,6 +243,20 @@ func (h LifeCycleHandler) Handle(ctx context.Context, vmRestore *virtv2.VirtualM
 				return reconcile.Result{}, err
 			case virtv2.MachineStopped:
 			default:
+				if runPolicy != virtv2.AlwaysOffPolicy {
+					err := h.updateVMRunPolicy(ctx, vmObj, virtv2.AlwaysOffPolicy)
+					if err != nil {
+						if errors.Is(err, restorer.ErrUpdating) {
+							setPhaseConditionToPending(cb, &vmRestore.Status.Phase, vmrestorecondition.VirtualMachineIsNotStopped, err.Error())
+							return reconcile.Result{}, nil
+						}
+						setPhaseConditionToFailed(cb, &vmRestore.Status.Phase, err)
+						return reconcile.Result{}, err
+					}
+					setPhaseConditionToPending(cb, &vmRestore.Status.Phase, vmrestorecondition.VirtualMachineIsNotStopped, "waiting for the virtual machine run policy will be updated")
+					return reconcile.Result{}, nil
+				}
+
 				err := h.stopVirtualMachine(ctx, vm.Name, vm.Namespace, string(vmRestore.UID))
 				if err != nil {
 					if errors.Is(err, restorer.ErrIncomplete) {
@@ -314,6 +333,22 @@ func (h LifeCycleHandler) Handle(ctx context.Context, vmRestore *virtv2.VirtualM
 		return reconcile.Result{}, err
 	}
 
+	vmObj, err := object.FetchObject(ctx, types.NamespacedName{Name: overridedVMName, Namespace: vm.Namespace}, h.client, &virtv2.VirtualMachine{})
+	if err != nil {
+		setPhaseConditionToFailed(cb, &vmRestore.Status.Phase, err)
+		return reconcile.Result{}, fmt.Errorf("failed to fetch the `VirtualMachine`: %w", err)
+	}
+
+	err = h.updateVMRunPolicy(ctx, vmObj, runPolicy)
+	if err != nil {
+		if errors.Is(err, restorer.ErrUpdating) {
+			setPhaseConditionToPending(cb, &vmRestore.Status.Phase, vmrestorecondition.VirtualMachineResourcesAreNotReady, err.Error())
+			return reconcile.Result{}, nil
+		}
+		setPhaseConditionToFailed(cb, &vmRestore.Status.Phase, err)
+		return reconcile.Result{}, err
+	}
+
 	vmRestore.Status.Phase = virtv2.VirtualMachineRestorePhaseInProgress
 	cb.
 		Status(metav1.ConditionFalse).
@@ -511,6 +546,10 @@ func (h LifeCycleHandler) startVirtualMachine(ctx context.Context, vmRestore *vi
 	}
 
 	if vmObj != nil {
+		if vmObj.Spec.RunPolicy == virtv2.AlwaysOffPolicy || vmObj.Spec.RunPolicy == virtv2.ManualPolicy {
+			return nil
+		}
+
 		if vmObj.Status.Phase == virtv2.MachineStopped {
 			vmopStart := newVMRestoreVMOP(vmName, vmRestore.Namespace, string(vmRestore.UID), virtv2.VMOPTypeStart)
 			err := h.client.Create(ctx, vmopStart)
@@ -551,3 +590,18 @@ func (h LifeCycleHandler) getOverrridedVMName(overrideValidators []OverrideValid
 
 	return "", fmt.Errorf("failed to get the `VirtualMachine` name")
 }
+
+func (h LifeCycleHandler) updateVMRunPolicy(ctx context.Context, vmObj *virtv2.VirtualMachine, runPolicy virtv2.RunPolicy) error {
+	vmObj.Spec.RunPolicy = runPolicy
+
+	err := h.client.Update(ctx, vmObj)
+	if err != nil {
+		if k8serrors.IsConflict(err) {
+			return fmt.Errorf("waiting for the virtual machine run policy %w", restorer.ErrUpdating)
+		} else {
+			return fmt.Errorf("failed to update the virtual machine run policy: %w", err)
+		}
+	}
+
+	return nil
+}

images/virtualization-artifact/pkg/controller/vmrestore/internal/restorer/vm_restorer.go

@@ -46,6 +46,9 @@ func NewVirtualMachineOverrideValidator(vmTmpl *virtv2.VirtualMachine, client cl
 		vmTmpl.Annotations = make(map[string]string)
 		vmTmpl.Annotations[annotations.AnnVMRestore] = vmRestoreUID
 	}
+
+	vmTmpl.Spec.RunPolicy = virtv2.AlwaysOffPolicy
+
 	return &VirtualMachineOverrideValidator{
 		vm: &virtv2.VirtualMachine{
 			TypeMeta: metav1.TypeMeta{

tests/e2e/testdata/vm-restore-force/vm/kustomization.yaml

@@ -2,3 +2,4 @@ apiVersion: kustomize.config.k8s.io/v1beta1
 kind: Kustomization
 resources:
   - overlays/vm-exists
+  - overlays/vm-exists-always-on

tests/e2e/testdata/vm-restore-force/vm/overlays/vm-exists-always-on/kustomization.yaml

@@ -0,0 +1,20 @@
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+nameSuffix: -always-on-restore-force
+resources:
+  - ../../base
+patches:
+  - patch: |-
+      - op: replace
+        path: /spec/runPolicy
+        value: AlwaysOn
+    target:
+      kind: VirtualMachine
+      name: vm
+  - patch: |-
+      - op: replace
+        path: /spec/disruptions/restartApprovalMode
+        value: Automatic
+    target:
+      kind: VirtualMachine
+      name: vm

tests/e2e/testdata/vm-restore-force/vm/overlays/vm-exists/kustomization.yaml

@@ -10,4 +10,4 @@ patches:
         value: Automatic
     target:
       kind: VirtualMachine
-      name: vm-exists
+      name: vm

tests/e2e/vm_restore_force_test.go

@@ -45,7 +45,6 @@ var _ = Describe("VirtualMachineRestoreForce", SIGRestoration(), ginkgoutil.Comm
 		ctx                 context.Context
 		cancel              context.CancelFunc
 		storageClass        *storagev1.StorageClass
-		volumeSnapshotClass string
 		namespace           string
 		testCaseLabel       = map[string]string{"testcase": "vm-restore-force"}
 		additionalDiskLabel = map[string]string{"additionalDisk": "vm-restore-force"}
@@ -140,7 +139,6 @@ var _ = Describe("VirtualMachineRestoreForce", SIGRestoration(), ginkgoutil.Comm
 					vmsnapshot := NewVirtualMachineSnapshot(
 						vm.Name, vm.Namespace,
 						storageClass.Name,
-						volumeSnapshotClass,
 						true,
 						virtv2.KeepIPAddressAlways,
 						testCaseLabel,
@@ -274,7 +272,7 @@ var _ = Describe("VirtualMachineRestoreForce", SIGRestoration(), ginkgoutil.Comm
 })
 
 func NewVirtualMachineSnapshot(
-	vmName, vmNamespace, storageClass, volumeSnapshotClass string,
+	vmName, vmNamespace, storageClass string,
 	requiredConsistency bool,
 	keepIPaddress virtv2.KeepIPAddress,
 	labels map[string]string,