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     refresh: function() {
  57         let me = this;
  58         // can only refresh if we're loaded at least once and are not currently loading
  59         if (!me.isLoading() && me.isLoaded()) {
  60             let records = (me.getData().getSource() || me.getData()).getRange();
  61             me.fireEvent('load', me, records);
  62         }
  63     },
  64
  65     constructor: function(config) {
  66         let me = this;
  67
  68         config = config || {};
  69
  70         let field_defaults = {
  71             type: {
  72                 header: gettext('Type'),
  73                 type: 'string',
  74                 renderer: PVE.Utils.render_resource_type,
  75                 sortable: true,
  76                 hideable: false,
  77                 width: 100,
  78             },
  79             id: {
  80                 header: 'ID',
  81                 type: 'string',
  82                 hidden: true,
  83                 sortable: true,
  84                 width: 80,
  85             },
  86             running: {
  87                 header: gettext('Online'),
  88                 type: 'boolean',
  89                 renderer: Proxmox.Utils.format_boolean,
  90                 hidden: true,
  91                 convert: function(value, record) {
  92                     var info = record.data;
  93                     return Ext.isNumeric(info.uptime) && info.uptime > 0;
  94                 },
  95             },
  96             text: {
  97                 header: gettext('Description'),
  98                 type: 'string',
  99                 sortable: true,
 100                 width: 200,
 101                 convert: function(value, record) {
 102                     if (value) {
 103                         return value;
 104                     }
 105
 106                     let info = record.data, text;
 107                     if (Ext.isNumeric(info.vmid) && info.vmid > 0) {
 108                         text = String(info.vmid);
 109                         if (info.name) {
 110                             text += " (" + info.name + ')';
 111                         }
 112                     } else { // node, pool, storage
 113                         text = info[info.type] || info.id;
 114                         if (info.node && info.type !== 'node') {
 115                             text += " (" + info.node + ")";
 116                         }
 117                     }
 118
 119                     return text;
 120                 },
 121             },
 122             vmid: {
 123                 header: 'VMID',
 124                 type: 'integer',
 125                 hidden: true,
 126                 sortable: true,
 127                 width: 80,
 128             },
 129             name: {
 130                 header: gettext('Name'),
 131                 hidden: true,
 132                 sortable: true,
 133                 type: 'string',
 134             },
 135             disk: {
 136                 header: gettext('Disk usage'),
 137                 type: 'integer',
 138                 renderer: PVE.Utils.render_disk_usage,
 139                 sortable: true,
 140                 width: 100,
 141                 hidden: true,
 142             },
 143             diskuse: {
 144                 header: gettext('Disk usage') + " %",
 145                 type: 'number',
 146                 sortable: true,
 147                 renderer: PVE.Utils.render_disk_usage_percent,
 148                 width: 100,
 149                 calculate: PVE.Utils.calculate_disk_usage,
 150                 sortType: 'asFloat',
 151             },
 152             maxdisk: {
 153                 header: gettext('Disk size'),
 154                 type: 'integer',
 155                 renderer: Proxmox.Utils.render_size,
 156                 sortable: true,
 157                 hidden: true,
 158                 width: 100,
 159             },
 160             mem: {
 161                 header: gettext('Memory usage'),
 162                 type: 'integer',
 163                 renderer: PVE.Utils.render_mem_usage,
 164                 sortable: true,
 165                 hidden: true,
 166                 width: 100,
 167             },
 168             memuse: {
 169                 header: gettext('Memory usage') + " %",
 170                 type: 'number',
 171                 renderer: PVE.Utils.render_mem_usage_percent,
 172                 calculate: PVE.Utils.calculate_mem_usage,
 173                 sortType: 'asFloat',
 174                 sortable: true,
 175                 width: 100,
 176             },
 177             maxmem: {
 178                 header: gettext('Memory size'),
 179                 type: 'integer',
 180                 renderer: Proxmox.Utils.render_size,
 181                 hidden: true,
 182                 sortable: true,
 183                 width: 100,
 184             },
 185             cpu: {
 186                 header: gettext('CPU usage'),
 187                 type: 'float',
 188                 renderer: Proxmox.Utils.render_cpu,
 189                 sortable: true,
 190                 width: 100,
 191             },
 192             maxcpu: {
 193                 header: gettext('maxcpu'),
 194                 type: 'integer',
 195                 hidden: true,
 196                 sortable: true,
 197                 width: 60,
 198             },
 199             diskread: {
 200                 header: gettext('Total Disk Read'),
 201                 type: 'integer',
 202                 hidden: true,
 203                 sortable: true,
 204                 renderer: Proxmox.Utils.format_size,
 205                 width: 100,
 206             },
 207             diskwrite: {
 208                 header: gettext('Total Disk Write'),
 209                 type: 'integer',
 210                 hidden: true,
 211                 sortable: true,
 212                 renderer: Proxmox.Utils.format_size,
 213                 width: 100,
 214             },
 215             netin: {
 216                 header: gettext('Total NetIn'),
 217                 type: 'integer',
 218                 hidden: true,
 219                 sortable: true,
 220                 renderer: Proxmox.Utils.format_size,
 221                 width: 100,
 222             },
 223             netout: {
 224                 header: gettext('Total NetOut'),
 225                 type: 'integer',
 226                 hidden: true,
 227                 sortable: true,
 228                 renderer: Proxmox.Utils.format_size,
 229                 width: 100,
 230             },
 231             template: {
 232                 header: gettext('Template'),
 233                 type: 'integer',
 234                 hidden: true,
 235                 sortable: true,
 236                 width: 60,
 237             },
 238             uptime: {
 239                 header: gettext('Uptime'),
 240                 type: 'integer',
 241                 renderer: Proxmox.Utils.render_uptime,
 242                 sortable: true,
 243                 width: 110,
 244             },
 245             node: {
 246                 header: gettext('Node'),
 247                 type: 'string',
 248                 hidden: true,
 249                 sortable: true,
 250                 width: 110,
 251             },
 252             storage: {
 253                 header: gettext('Storage'),
 254                 type: 'string',
 255                 hidden: true,
 256                 sortable: true,
 257                 width: 110,
 258             },
 259             pool: {
 260                 header: gettext('Pool'),
 261                 type: 'string',
 262                 hidden: true,
 263                 sortable: true,
 264                 width: 110,
 265             },
 266             hastate: {
 267                 header: gettext('HA State'),
 268                 type: 'string',
 269                 defaultValue: 'unmanaged',
 270                 hidden: true,
 271                 sortable: true,
 272             },
 273             status: {
 274                 header: gettext('Status'),
 275                 type: 'string',
 276                 hidden: true,
 277                 sortable: true,
 278                 width: 110,
 279             },
 280             lock: {
 281                 header: gettext('Lock'),
 282                 type: 'string',
 283                 hidden: true,
 284                 sortable: true,
 285                 width: 110,
 286             },
 287             hostcpu: {
 288                 header: gettext('Host CPU usage'),
 289                 type: 'float',
 290                 renderer: PVE.Utils.render_hostcpu,
 291                 calculate: PVE.Utils.calculate_hostcpu,
 292                 sortType: 'asFloat',
 293                 sortable: true,
 294                 width: 100,
 295             },
 296             hostmemuse: {
 297                 header: gettext('Host Memory usage') + " %",
 298                 type: 'number',
 299                 renderer: PVE.Utils.render_hostmem_usage_percent,
 300                 calculate: PVE.Utils.calculate_hostmem_usage,
 301                 sortType: 'asFloat',
 302                 sortable: true,
 303                 width: 100,
 304             },
 305             tags: {
 306                 header: gettext('Tags'),
 307                 renderer: (value) => PVE.Utils.renderTags(value, PVE.UIOptions.tagOverrides),
 308                 type: 'string',
 309                 sortable: true,
 310                 flex: 1,
 311             },
 312             // note: flex only last column to keep info closer together
 313         };
 314
 315         let fields = [];
 316         let fieldNames = [];
 317         Ext.Object.each(field_defaults, function(key, value) {
 318             var field = { name: key, type: value.type };
 319             if (Ext.isDefined(value.convert)) {
 320                 field.convert = value.convert;
 321             }
 322
 323             if (Ext.isDefined(value.calculate)) {
 324                 field.calculate = value.calculate;
 325             }
 326
 327             if (Ext.isDefined(value.defaultValue)) {
 328                 field.defaultValue = value.defaultValue;
 329             }
 330
 331             fields.push(field);
 332             fieldNames.push(key);
 333         });
 334
 335         Ext.define('PVEResources', {
 336             extend: "Ext.data.Model",
 337             fields: fields,
 338             proxy: {
 339                 type: 'proxmox',
 340                 url: '/api2/json/cluster/resources',
 341             },
 342         });
 343
 344         Ext.define('PVETree', {
 345             extend: "Ext.data.Model",
 346             fields: fields,
 347             proxy: { type: 'memory' },
 348         });
 349
 350         Ext.apply(config, {
 351             storeid: 'PVEResources',
 352             model: 'PVEResources',
 353             defaultColumns: function() {
 354                 let res = [];
 355                 Ext.Object.each(field_defaults, function(field, info) {
 356                     let fieldInfo = Ext.apply({ dataIndex: field }, info);
 357                     res.push(fieldInfo);
 358                 });
 359                 return res;
 360             },
 361             fieldNames: fieldNames,
 362         });
 363
 364         me.callParent([config]);
 365     },
 366 });