Coverage for ocp_resources/virtual_machine_restore.py: 0%

1# -*- coding: utf-8 -*- 

2 

3from kubernetes.dynamic.exceptions import ResourceNotFoundError 

4 

5from ocp_resources.utils.constants import PROTOCOL_ERROR_EXCEPTION_DICT, TIMEOUT_4MINUTES 

6from ocp_resources.resource import NamespacedResource 

7from timeout_sampler import TimeoutSampler, TimeoutWatch 

8from ocp_resources.virtual_machine import VirtualMachine 

9 

10 

11class VirtualMachineRestore(NamespacedResource): 

12 """ 

13 VirtualMachineRestore object. 

14 """ 

15 

16 api_group = NamespacedResource.ApiGroup.SNAPSHOT_KUBEVIRT_IO 

17 

18 def __init__( 

19 self, 

20 name=None, 

21 namespace=None, 

22 vm_name=None, 

23 snapshot_name=None, 

24 client=None, 

25 teardown=True, 

26 yaml_file=None, 

27 delete_timeout=TIMEOUT_4MINUTES, 

28 **kwargs, 

29 ): 

30 super().__init__( 

31 name=name, 

32 namespace=namespace, 

33 client=client, 

34 teardown=teardown, 

35 yaml_file=yaml_file, 

36 delete_timeout=delete_timeout, 

37 **kwargs, 

38 ) 

39 self.vm_name = vm_name 

40 self.snapshot_name = snapshot_name 

41 

42 def to_dict(self) -> None: 

43 super().to_dict() 

44 if not self.kind_dict and not self.yaml_file: 

45 spec = self.res.setdefault("spec", {}) 

46 spec.setdefault("target", {})["apiGroup"] = NamespacedResource.ApiGroup.KUBEVIRT_IO 

47 spec["target"]["kind"] = VirtualMachine.kind 

48 spec["target"]["name"] = self.vm_name 

49 spec["virtualMachineSnapshotName"] = self.snapshot_name 

50 

51 def wait_complete(self, status=True, timeout=TIMEOUT_4MINUTES): 

52 """ 

53 Wait for VirtualMachineRestore to be in status complete 

54 

55 Args: 

56 status: Expected status: True for a completed restore operation, False otherwise. 

57 timeout (int): Time to wait. 

58 

59 Raises: 

60 TimeoutExpiredError: If timeout reached. 

61 """ 

62 self.logger.info(f"Wait for {self.kind} {self.name} status to be complete = {status}") 

63 

64 timeout_watcher = TimeoutWatch(timeout=timeout) 

65 for sample in TimeoutSampler( 

66 wait_timeout=timeout, 

67 sleep=1, 

68 func=lambda: self.exists, 

69 ): 

70 if sample: 

71 break 

72 

73 samples = TimeoutSampler( 

74 wait_timeout=timeout_watcher.remaining_time(), 

75 sleep=1, 

76 exceptions_dict=PROTOCOL_ERROR_EXCEPTION_DICT, 

77 func=lambda: self.instance.get("status", {}).get("complete") == status, 

78 ) 

79 for sample in samples: 

80 if sample: 

81 return 

82 

83 def wait_restore_done(self, timeout=TIMEOUT_4MINUTES): 

84 """ 

85 Wait for the the restore to be done. This check 2 parameters, the restore status to be complete 

86 and the VM status restoreInProgress to be None. 

87 

88 Args: 

89 timeout (int): Time to wait. 

90 

91 Raises: 

92 TimeoutExpiredError: If timeout reached. 

93 """ 

94 self.wait_complete(timeout=timeout) 

95 

96 vm = VirtualMachine( 

97 client=self.client, 

98 namespace=self.namespace, 

99 name=self.vm_name, 

100 ) 

101 

102 if vm.exists: 

103 return vm.wait_for_status_none(status="restoreInProgress", timeout=timeout) 

104 raise ResourceNotFoundError(f"VirtualMachine: {vm.name} not found")