]>
Commit | Line | Data |
---|---|---|
1 | Ext.define('PVE.data.ResourceStore', { | |
2 | extend: 'Proxmox.data.UpdateStore', | |
3 | singleton: true, | |
4 | ||
5 | findVMID: function(vmid) { | |
6 | var me = this, i; | |
7 | ||
8 | return me.findExact('vmid', parseInt(vmid, 10)) >= 0; | |
9 | }, | |
10 | ||
11 | // returns the cached data from all nodes | |
12 | getNodes: function() { | |
13 | var me = this; | |
14 | ||
15 | var nodes = []; | |
16 | me.each(function(record) { | |
17 | if (record.get('type') == "node") { | |
18 | nodes.push(record.getData()); | |
19 | } | |
20 | }); | |
21 | ||
22 | return nodes; | |
23 | }, | |
24 | ||
25 | storageIsShared: function(storage_path) { | |
26 | var me = this; | |
27 | ||
28 | var index = me.findExact('id', storage_path); | |
29 | ||
30 | return me.getAt(index).data.shared; | |
31 | }, | |
32 | ||
33 | guestNode: function(vmid) { | |
34 | var me = this; | |
35 | ||
36 | var index = me.findExact('vmid', parseInt(vmid, 10)); | |
37 | ||
38 | return me.getAt(index).data.node; | |
39 | }, | |
40 | ||
41 | guestName: function(vmid) { | |
42 | let me = this; | |
43 | let index = me.findExact('vmid', parseInt(vmid, 10)); | |
44 | if (index < 0) { | |
45 | return '-'; | |
46 | } | |
47 | let rec = me.getAt(index).data; | |
48 | if ('name' in rec) { | |
49 | return rec.name; | |
50 | } | |
51 | return ''; | |
52 | }, | |
53 | ||
54 | constructor: function(config) { | |
55 | // fixme: how to avoid those warnings | |
56 | ||
57 | var me = this; | |
58 | ||
59 | config = config || {}; | |
60 | ||
61 | var field_defaults = { | |
62 | type: { | |
63 | header: gettext('Type'), | |
64 | type: 'string', | |
65 | renderer: PVE.Utils.render_resource_type, | |
66 | sortable: true, | |
67 | hideable: false, | |
68 | width: 100, | |
69 | }, | |
70 | id: { | |
71 | header: 'ID', | |
72 | type: 'string', | |
73 | hidden: true, | |
74 | sortable: true, | |
75 | width: 80, | |
76 | }, | |
77 | running: { | |
78 | header: gettext('Online'), | |
79 | type: 'boolean', | |
80 | renderer: Proxmox.Utils.format_boolean, | |
81 | hidden: true, | |
82 | convert: function(value, record) { | |
83 | var info = record.data; | |
84 | return Ext.isNumeric(info.uptime) && info.uptime > 0; | |
85 | }, | |
86 | }, | |
87 | text: { | |
88 | header: gettext('Description'), | |
89 | type: 'string', | |
90 | sortable: true, | |
91 | width: 200, | |
92 | convert: function(value, record) { | |
93 | var info = record.data; | |
94 | var text; | |
95 | ||
96 | if (value) { | |
97 | return value; | |
98 | } | |
99 | ||
100 | if (Ext.isNumeric(info.vmid) && info.vmid > 0) { | |
101 | text = String(info.vmid); | |
102 | if (info.name) { | |
103 | text += " (" + info.name + ')'; | |
104 | } | |
105 | } else { // node, pool, storage | |
106 | text = info[info.type] || info.id; | |
107 | if (info.node && info.type !== 'node') { | |
108 | text += " (" + info.node + ")"; | |
109 | } | |
110 | } | |
111 | ||
112 | return text; | |
113 | }, | |
114 | }, | |
115 | vmid: { | |
116 | header: 'VMID', | |
117 | type: 'integer', | |
118 | hidden: true, | |
119 | sortable: true, | |
120 | width: 80, | |
121 | }, | |
122 | name: { | |
123 | header: gettext('Name'), | |
124 | hidden: true, | |
125 | sortable: true, | |
126 | type: 'string', | |
127 | }, | |
128 | disk: { | |
129 | header: gettext('Disk usage'), | |
130 | type: 'integer', | |
131 | renderer: PVE.Utils.render_disk_usage, | |
132 | sortable: true, | |
133 | width: 100, | |
134 | hidden: true, | |
135 | }, | |
136 | diskuse: { | |
137 | header: gettext('Disk usage') + " %", | |
138 | type: 'number', | |
139 | sortable: true, | |
140 | renderer: PVE.Utils.render_disk_usage_percent, | |
141 | width: 100, | |
142 | calculate: PVE.Utils.calculate_disk_usage, | |
143 | sortType: 'asFloat', | |
144 | }, | |
145 | maxdisk: { | |
146 | header: gettext('Disk size'), | |
147 | type: 'integer', | |
148 | renderer: Proxmox.Utils.render_size, | |
149 | sortable: true, | |
150 | hidden: true, | |
151 | width: 100, | |
152 | }, | |
153 | mem: { | |
154 | header: gettext('Memory usage'), | |
155 | type: 'integer', | |
156 | renderer: PVE.Utils.render_mem_usage, | |
157 | sortable: true, | |
158 | hidden: true, | |
159 | width: 100, | |
160 | }, | |
161 | memuse: { | |
162 | header: gettext('Memory usage') + " %", | |
163 | type: 'number', | |
164 | renderer: PVE.Utils.render_mem_usage_percent, | |
165 | calculate: PVE.Utils.calculate_mem_usage, | |
166 | sortType: 'asFloat', | |
167 | sortable: true, | |
168 | width: 100, | |
169 | }, | |
170 | maxmem: { | |
171 | header: gettext('Memory size'), | |
172 | type: 'integer', | |
173 | renderer: Proxmox.Utils.render_size, | |
174 | hidden: true, | |
175 | sortable: true, | |
176 | width: 100, | |
177 | }, | |
178 | cpu: { | |
179 | header: gettext('CPU usage'), | |
180 | type: 'float', | |
181 | renderer: Proxmox.Utils.render_cpu, | |
182 | sortable: true, | |
183 | width: 100, | |
184 | }, | |
185 | maxcpu: { | |
186 | header: gettext('maxcpu'), | |
187 | type: 'integer', | |
188 | hidden: true, | |
189 | sortable: true, | |
190 | width: 60, | |
191 | }, | |
192 | diskread: { | |
193 | header: gettext('Total Disk Read'), | |
194 | type: 'integer', | |
195 | hidden: true, | |
196 | sortable: true, | |
197 | renderer: Proxmox.Utils.format_size, | |
198 | width: 100, | |
199 | }, | |
200 | diskwrite: { | |
201 | header: gettext('Total Disk Write'), | |
202 | type: 'integer', | |
203 | hidden: true, | |
204 | sortable: true, | |
205 | renderer: Proxmox.Utils.format_size, | |
206 | width: 100, | |
207 | }, | |
208 | netin: { | |
209 | header: gettext('Total NetIn'), | |
210 | type: 'integer', | |
211 | hidden: true, | |
212 | sortable: true, | |
213 | renderer: Proxmox.Utils.format_size, | |
214 | width: 100, | |
215 | }, | |
216 | netout: { | |
217 | header: gettext('Total NetOut'), | |
218 | type: 'integer', | |
219 | hidden: true, | |
220 | sortable: true, | |
221 | renderer: Proxmox.Utils.format_size, | |
222 | width: 100, | |
223 | }, | |
224 | template: { | |
225 | header: gettext('Template'), | |
226 | type: 'integer', | |
227 | hidden: true, | |
228 | sortable: true, | |
229 | width: 60, | |
230 | }, | |
231 | uptime: { | |
232 | header: gettext('Uptime'), | |
233 | type: 'integer', | |
234 | renderer: Proxmox.Utils.render_uptime, | |
235 | sortable: true, | |
236 | width: 110, | |
237 | }, | |
238 | node: { | |
239 | header: gettext('Node'), | |
240 | type: 'string', | |
241 | hidden: true, | |
242 | sortable: true, | |
243 | width: 110, | |
244 | }, | |
245 | storage: { | |
246 | header: gettext('Storage'), | |
247 | type: 'string', | |
248 | hidden: true, | |
249 | sortable: true, | |
250 | width: 110, | |
251 | }, | |
252 | pool: { | |
253 | header: gettext('Pool'), | |
254 | type: 'string', | |
255 | hidden: true, | |
256 | sortable: true, | |
257 | width: 110, | |
258 | }, | |
259 | hastate: { | |
260 | header: gettext('HA State'), | |
261 | type: 'string', | |
262 | defaultValue: 'unmanaged', | |
263 | hidden: true, | |
264 | sortable: true, | |
265 | }, | |
266 | status: { | |
267 | header: gettext('Status'), | |
268 | type: 'string', | |
269 | hidden: true, | |
270 | sortable: true, | |
271 | width: 110, | |
272 | }, | |
273 | lock: { | |
274 | header: gettext('Lock'), | |
275 | type: 'string', | |
276 | hidden: true, | |
277 | sortable: true, | |
278 | width: 110, | |
279 | }, | |
280 | hostcpu: { | |
281 | header: gettext('Host CPU usage'), | |
282 | type: 'float', | |
283 | renderer: PVE.Utils.render_hostcpu, | |
284 | calculate: PVE.Utils.calculate_hostcpu, | |
285 | sortType: 'asFloat', | |
286 | sortable: true, | |
287 | width: 100 | |
288 | }, | |
289 | hostmemuse: { | |
290 | header: gettext('Host Memory usage') + " %", | |
291 | type: 'number', | |
292 | renderer: PVE.Utils.render_hostmem_usage_percent, | |
293 | calculate: PVE.Utils.calculate_hostmem_usage, | |
294 | sortType: 'asFloat', | |
295 | sortable: true, | |
296 | width: 100 | |
297 | }, | |
298 | }; | |
299 | ||
300 | var fields = []; | |
301 | var fieldNames = []; | |
302 | Ext.Object.each(field_defaults, function(key, value) { | |
303 | var field = { name: key, type: value.type }; | |
304 | if (Ext.isDefined(value.convert)) { | |
305 | field.convert = value.convert; | |
306 | } | |
307 | ||
308 | if (Ext.isDefined(value.calculate)) { | |
309 | field.calculate = value.calculate; | |
310 | } | |
311 | ||
312 | if (Ext.isDefined(value.defaultValue)) { | |
313 | field.defaultValue = value.defaultValue; | |
314 | } | |
315 | ||
316 | fields.push(field); | |
317 | fieldNames.push(key); | |
318 | }); | |
319 | ||
320 | Ext.define('PVEResources', { | |
321 | extend: "Ext.data.Model", | |
322 | fields: fields, | |
323 | proxy: { | |
324 | type: 'proxmox', | |
325 | url: '/api2/json/cluster/resources', | |
326 | }, | |
327 | }); | |
328 | ||
329 | Ext.define('PVETree', { | |
330 | extend: "Ext.data.Model", | |
331 | fields: fields, | |
332 | proxy: { type: 'memory' }, | |
333 | }); | |
334 | ||
335 | Ext.apply(config, { | |
336 | storeid: 'PVEResources', | |
337 | model: 'PVEResources', | |
338 | defaultColumns: function() { | |
339 | var res = []; | |
340 | Ext.Object.each(field_defaults, function(field, info) { | |
341 | var fi = Ext.apply({ dataIndex: field }, info); | |
342 | res.push(fi); | |
343 | }); | |
344 | return res; | |
345 | }, | |
346 | fieldNames: fieldNames, | |
347 | }); | |
348 | ||
349 | me.callParent([config]); | |
350 | }, | |
351 | }); |