www/manager6/data/ResourceStore.js

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