Coverage for ocp_resources/persistent_volume_claim.py: 0%

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

2 

3from ocp_resources.utils.constants import TIMEOUT_4MINUTES 

4from ocp_resources.resource import NamespacedResource 

5 

6 

7class PersistentVolumeClaim(NamespacedResource): 

8 """ 

9 PersistentVolumeClaim object 

10 """ 

11 

12 api_version = NamespacedResource.ApiVersion.V1 

13 

14 class Status(NamespacedResource.Status): 

15 BOUND = "Bound" 

16 

17 class AccessMode: 

18 """ 

19 AccessMode object. 

20 """ 

21 

22 RWO = "ReadWriteOnce" 

23 ROX = "ReadOnlyMany" 

24 RWX = "ReadWriteMany" 

25 

26 class VolumeMode: 

27 """ 

28 VolumeMode object 

29 """ 

30 

31 BLOCK = "Block" 

32 FILE = "Filesystem" 

33 

34 def __init__( 

35 self, 

36 name=None, 

37 namespace=None, 

38 client=None, 

39 storage_class=None, 

40 accessmodes=None, 

41 volume_mode=VolumeMode.FILE, 

42 size=None, 

43 hostpath_node=None, 

44 teardown=True, 

45 yaml_file=None, 

46 delete_timeout=TIMEOUT_4MINUTES, 

47 pvlabel=None, 

48 **kwargs, 

49 ): 

50 super().__init__( 

51 name=name, 

52 namespace=namespace, 

53 client=client, 

54 teardown=teardown, 

55 yaml_file=yaml_file, 

56 delete_timeout=delete_timeout, 

57 **kwargs, 

58 ) 

59 self.accessmodes = accessmodes 

60 self.volume_mode = volume_mode 

61 self.size = size 

62 self.hostpath_node = hostpath_node 

63 self.storage_class = storage_class 

64 self.pvlabel = pvlabel 

65 

66 def to_dict(self) -> None: 

67 super().to_dict() 

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

69 self.res.update({ 

70 "spec": { 

71 "volumeMode": self.volume_mode, 

72 "accessModes": [self.accessmodes], 

73 "resources": {"requests": {"storage": self.size}}, 

74 } 

75 }) 

76 """ 

77 Hostpath-provisioner is "node aware", when using it, 

78 a node attribute on the claim must be introduced as follows. 

79 annotations: 

80 kubevirt.io/provisionOnNode: <specified_node_name> 

81 """ 

82 if self.hostpath_node: 

83 self.res["metadata"]["annotations"] = {"kubevirt.io/provisionOnNode": self.hostpath_node} 

84 if self.storage_class: 

85 self.res["spec"]["storageClassName"] = self.storage_class 

86 

87 if self.pvlabel: 

88 self.res["spec"]["selector"] = {"matchLabels": {"pvLabel": self.pvlabel}} 

89 

90 def bound(self): 

91 """ 

92 Check if PVC is bound 

93 

94 Returns: 

95 bool: True if bound else False 

96 """ 

97 self.logger.info(f"Check if {self.kind} {self.name} is bound") 

98 return self.status == self.Status.BOUND 

99 

100 @property 

101 def selected_node(self): 

102 return self.instance.metadata.annotations.get("volume.kubernetes.io/selected-node") 

103 

104 @property 

105 def use_populator(self): 

106 return self.instance.metadata.annotations.get(f"{self.ApiGroup.CDI_KUBEVIRT_IO}/storage.usePopulator") == "true" 

107 

108 @property 

109 def prime_pvc(self): 

110 if self.use_populator: 

111 return PersistentVolumeClaim( 

112 name=f"prime-{self.instance.metadata.uid}", 

113 namespace=self.namespace, 

114 client=self.client, 

115 )