Coverage for virtualization/tables/virtualmachines.py: 95%

1import django_tables2 as tables 

2from django.utils.translation import gettext_lazy as _ 

3 

4from dcim.tables.devices import BaseInterfaceTable 

5from netbox.tables import NetBoxTable, PrimaryModelTable, columns 

6from tenancy.tables import ContactsColumnMixin, TenancyColumnsMixin 

7from utilities.templatetags.helpers import humanize_disk_capacity, humanize_ram_capacity 

8 

9from ..models import VirtualDisk, VirtualMachine, VirtualMachineType, VMInterface 

10from .template_code import * 

11 

12__all__ = ( 

13 'VMInterfaceTable', 

14 'VirtualDiskTable', 

15 'VirtualMachineTable', 

16 'VirtualMachineTypeTable', 

17 'VirtualMachineVMInterfaceTable', 

18 'VirtualMachineVirtualDiskTable', 

19) 

20 

21# 

22# Virtual machine types 

23# 

24 

25 

26class VirtualMachineTypeTable(PrimaryModelTable): 

27 name = tables.Column( 

28 verbose_name=_('Name'), 

29 linkify=True, 

30 ) 

31 default_platform = tables.Column( 

32 verbose_name=_('Default platform'), 

33 linkify=True, 

34 ) 

35 virtual_machine_count = tables.Column( 

36 verbose_name=_('VM count') 

37 ) 

38 tags = columns.TagColumn( 

39 url_name='virtualization:virtualmachinetype_list' 

40 ) 

41 

42 class Meta(PrimaryModelTable.Meta): 

43 model = VirtualMachineType 

44 fields = ( 

45 'pk', 'id', 'name', 'slug', 'default_platform', 'default_vcpus', 'default_memory', 'virtual_machine_count', 

46 'description', 'comments', 'tags', 'created', 'last_updated', 

47 ) 

48 default_columns = ( 

49 'pk', 'name', 'default_platform', 'default_vcpus', 'default_memory', 'virtual_machine_count', 'description', 

50 ) 

51 

52 def render_default_memory(self, value): 

53 return humanize_ram_capacity(value) 

54 

55 

56# 

57# Virtual machines 

58# 

59 

60 

61class VirtualMachineTable(TenancyColumnsMixin, ContactsColumnMixin, PrimaryModelTable): 

62 name = tables.Column( 

63 verbose_name=_('Name'), 

64 linkify=True 

65 ) 

66 virtual_machine_type = tables.Column( 

67 verbose_name=_('Type'), 

68 linkify=True, 

69 ) 

70 status = columns.ChoiceFieldColumn( 

71 verbose_name=_('Status'), 

72 ) 

73 start_on_boot = columns.ChoiceFieldColumn( 

74 verbose_name=_('Start on boot'), 

75 ) 

76 site = tables.Column( 

77 verbose_name=_('Site'), 

78 linkify=True 

79 ) 

80 cluster = tables.Column( 

81 verbose_name=_('Cluster'), 

82 linkify=True 

83 ) 

84 device = tables.Column( 

85 verbose_name=_('Device'), 

86 linkify=True 

87 ) 

88 role = columns.ColoredLabelColumn( 

89 verbose_name=_('Role'), 

90 ) 

91 platform = tables.Column( 

92 linkify=True, 

93 verbose_name=_('Platform') 

94 ) 

95 primary_ip4 = tables.Column( 

96 linkify=True, 

97 verbose_name=_('IPv4 Address') 

98 ) 

99 primary_ip6 = tables.Column( 

100 linkify=True, 

101 verbose_name=_('IPv6 Address') 

102 ) 

103 primary_ip = tables.Column( 

104 linkify=True, 

105 order_by=('primary_ip4', 'primary_ip6'), 

106 verbose_name=_('IP Address') 

107 ) 

108 tags = columns.TagColumn( 

109 url_name='virtualization:virtualmachine_list' 

110 ) 

111 interface_count = tables.Column( 

112 verbose_name=_('Interfaces') 

113 ) 

114 virtual_disk_count = tables.Column( 

115 verbose_name=_('Virtual Disks') 

116 ) 

117 config_template = tables.Column( 

118 verbose_name=_('Config Template'), 

119 linkify=True 

120 ) 

121 disk = tables.Column( 

122 verbose_name=_('Disk'), 

123 ) 

124 

125 class Meta(PrimaryModelTable.Meta): 

126 model = VirtualMachine 

127 fields = ( 

128 'pk', 'id', 'name', 'virtual_machine_type', 'role', 'status', 'start_on_boot', 'site', 'cluster', 'device', 

129 'platform', 'primary_ip4', 'primary_ip6', 'primary_ip', 'vcpus', 'memory', 'disk', 'description', 'serial', 

130 'tenant_group', 'tenant', 'contacts', 'comments', 'tags', 'config_template', 'created', 'last_updated', 

131 ) 

132 default_columns = ( 

133 'pk', 'name', 'virtual_machine_type', 'role', 'status', 'site', 'cluster', 'tenant', 

134 'vcpus', 'memory', 'disk', 'primary_ip', 

135 ) 

136 

137 def render_memory(self, value): 

138 return humanize_ram_capacity(value) 

139 

140 def render_disk(self, value): 

141 return humanize_disk_capacity(value) 

142 

143 

144# 

145# VM components 

146# 

147 

148class VMInterfaceTable(BaseInterfaceTable): 

149 virtual_machine = tables.Column( 

150 verbose_name=_('Virtual Machine'), 

151 linkify=True 

152 ) 

153 name = tables.Column( 

154 verbose_name=_('Name'), 

155 linkify=True 

156 ) 

157 vrf = tables.Column( 

158 verbose_name=_('VRF'), 

159 linkify=True 

160 ) 

161 tags = columns.TagColumn( 

162 url_name='virtualization:vminterface_list' 

163 ) 

164 

165 class Meta(NetBoxTable.Meta): 

166 model = VMInterface 

167 fields = ( 

168 'pk', 'id', 'name', 'virtual_machine', 'enabled', 'mtu', 'mode', 'description', 'tags', 'vrf', 

169 'primary_mac_address', 'l2vpn', 'tunnel', 'ip_addresses', 'fhrp_groups', 'untagged_vlan', 'tagged_vlans', 

170 'qinq_svlan', 'created', 'last_updated', 'vlan_translation_policy', 

171 ) 

172 default_columns = ('pk', 'name', 'virtual_machine', 'enabled', 'description') 

173 

174 

175class VirtualMachineVMInterfaceTable(VMInterfaceTable): 

176 parent = tables.Column( 

177 verbose_name=_('Parent'), 

178 linkify=True 

179 ) 

180 bridge = tables.Column( 

181 verbose_name=_('Bridge'), 

182 linkify=True 

183 ) 

184 actions = columns.ActionsColumn( 

185 actions=('edit', 'delete'), 

186 extra_buttons=VMINTERFACE_BUTTONS 

187 ) 

188 

189 class Meta(NetBoxTable.Meta): 

190 model = VMInterface 

191 fields = ( 

192 'pk', 'id', 'name', 'enabled', 'parent', 'bridge', 'primary_mac_address', 'mtu', 'mode', 'description', 

193 'tags', 'vrf', 'l2vpn', 'tunnel', 'ip_addresses', 'fhrp_groups', 'untagged_vlan', 'tagged_vlans', 

194 'qinq_svlan', 'actions', 

195 ) 

196 default_columns = ('pk', 'name', 'enabled', 'primary_mac_address', 'mtu', 'mode', 'description', 'ip_addresses') 

197 row_attrs = { 

198 'data-name': lambda record: record.name, 

199 'data-virtual': lambda record: "true", 

200 'data-enabled': lambda record: "true" if record.enabled else "false", 

201 } 

202 

203 

204class VirtualDiskTable(NetBoxTable): 

205 virtual_machine = tables.Column( 

206 verbose_name=_('Virtual Machine'), 

207 linkify=True 

208 ) 

209 name = tables.Column( 

210 verbose_name=_('Name'), 

211 linkify=True 

212 ) 

213 size = tables.Column( 

214 verbose_name=_('Size') 

215 ) 

216 tags = columns.TagColumn( 

217 url_name='virtualization:virtualdisk_list' 

218 ) 

219 

220 class Meta(NetBoxTable.Meta): 

221 model = VirtualDisk 

222 fields = ( 

223 'pk', 'id', 'virtual_machine', 'name', 'size', 'description', 'tags', 

224 ) 

225 default_columns = ('pk', 'name', 'virtual_machine', 'size', 'description') 

226 row_attrs = { 

227 'data-name': lambda record: record.name, 

228 } 

229 

230 def render_size(self, value): 

231 return humanize_disk_capacity(value) 

232 

233 

234class VirtualMachineVirtualDiskTable(VirtualDiskTable): 

235 actions = columns.ActionsColumn( 

236 actions=('edit', 'delete'), 

237 ) 

238 

239 class Meta(VirtualDiskTable.Meta): 

240 fields = ( 

241 'pk', 'id', 'name', 'size', 'description', 'tags', 'actions', 

242 ) 

243 default_columns = ('pk', 'name', 'size', 'description')