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         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     constructor: function(config) {
  26         // fixme: how to avoid those warnings
  27         /*jslint confusion: true */
  28
  29         var me = this;
  30
  31         config = config || {};
  32
  33         var field_defaults = {
  34             type: {
  35                 header: gettext('Type'),
  36                 type: 'string',
  37                 renderer: PVE.Utils.render_resource_type,
  38                 sortable: true,
  39                 hideable: false,
  40                 width: 100
  41             },
  42             id: {
  43                 header: 'ID',
  44                 type: 'string',
  45                 hidden: true,
  46                 sortable: true,
  47                 width: 80
  48             },
  49             running: {
  50                 header: gettext('Online'),
  51                 type: 'boolean',
  52                 renderer: Proxmox.Utils.format_boolean,
  53                 hidden: true,
  54                 convert: function(value, record) {
  55                     var info = record.data;
  56                     return (Ext.isNumeric(info.uptime) && (info.uptime > 0));
  57                 }
  58             },
  59             text: {
  60                 header: gettext('Description'),
  61                 type: 'string',
  62                 sortable: true,
  63                 width: 200,
  64                 convert: function(value, record) {
  65                     var info = record.data;
  66                     var text;
  67
  68                     if (value) {
  69                         return value;
  70                     }
  71
  72                     if (Ext.isNumeric(info.vmid) && info.vmid > 0) {
  73                         text = String(info.vmid);
  74                         if (info.name) {
  75                             text += " (" + info.name + ')';
  76                         }
  77                     } else { // node, pool, storage
  78                         text = info[info.type] || info.id;
  79                         if (info.node && info.type !== 'node') {
  80                             text += " (" + info.node + ")";
  81                         }
  82                     }
  83
  84                     return text;
  85                 }
  86             },
  87             vmid: {
  88                 header: 'VMID',
  89                 type: 'integer',
  90                 hidden: true,
  91                 sortable: true,
  92                 width: 80
  93             },
  94             name: {
  95                 header: gettext('Name'),
  96                 hidden: true,
  97                 sortable: true,
  98                 type: 'string'
  99             },
 100             disk: {
 101                 header: gettext('Disk usage'),
 102                 type: 'integer',
 103                 renderer: PVE.Utils.render_disk_usage,
 104                 sortable: true,
 105                 width: 100,
 106                 hidden: true
 107             },
 108             diskuse: {
 109                 header: gettext('Disk usage') + " %",
 110                 type: 'number',
 111                 sortable: true,
 112                 renderer: PVE.Utils.render_disk_usage_percent,
 113                 width: 100,
 114                 calculate: PVE.Utils.calculate_disk_usage,
 115                 sortType: 'asFloat'
 116             },
 117             maxdisk: {
 118                 header: gettext('Disk size'),
 119                 type: 'integer',
 120                 renderer: PVE.Utils.render_size,
 121                 sortable: true,
 122                 hidden: true,
 123                 width: 100
 124             },
 125             mem: {
 126                 header: gettext('Memory usage'),
 127                 type: 'integer',
 128                 renderer: PVE.Utils.render_mem_usage,
 129                 sortable: true,
 130                 hidden: true,
 131                 width: 100
 132             },
 133             memuse: {
 134                 header: gettext('Memory usage') + " %",
 135                 type: 'number',
 136                 renderer: PVE.Utils.render_mem_usage_percent,
 137                 calculate: PVE.Utils.calculate_mem_usage,
 138                 sortType: 'asFloat',
 139                 sortable: true,
 140                 width: 100
 141             },
 142             maxmem: {
 143                 header: gettext('Memory size'),
 144                 type: 'integer',
 145                 renderer: PVE.Utils.render_size,
 146                 hidden: true,
 147                 sortable: true,
 148                 width: 100
 149             },
 150             cpu: {
 151                 header: gettext('CPU usage'),
 152                 type: 'float',
 153                 renderer: PVE.Utils.render_cpu,
 154                 sortable: true,
 155                 width: 100
 156             },
 157             maxcpu: {
 158                 header: gettext('maxcpu'),
 159                 type: 'integer',
 160                 hidden: true,
 161                 sortable: true,
 162                 width: 60
 163             },
 164             diskread: {
 165                 header: gettext('Total Disk Read'),
 166                 type: 'integer',
 167                 hidden: true,
 168                 sortable: true,
 169                 renderer: Proxmox.Utils.format_size,
 170                 width: 100
 171             },
 172             diskwrite: {
 173                 header: gettext('Total Disk Write'),
 174                 type: 'integer',
 175                 hidden: true,
 176                 sortable: true,
 177                 renderer: Proxmox.Utils.format_size,
 178                 width: 100
 179             },
 180             netin: {
 181                 header: gettext('Total NetIn'),
 182                 type: 'integer',
 183                 hidden: true,
 184                 sortable: true,
 185                 renderer: Proxmox.Utils.format_size,
 186                 width: 100
 187             },
 188             netout: {
 189                 header: gettext('Total NetOut'),
 190                 type: 'integer',
 191                 hidden: true,
 192                 sortable: true,
 193                 renderer: Proxmox.Utils.format_size,
 194                 width: 100
 195             },
 196             template: {
 197                 header: gettext('Template'),
 198                 type: 'integer',
 199                 hidden: true,
 200                 sortable: true,
 201                 width: 60
 202             },
 203             uptime: {
 204                 header: gettext('Uptime'),
 205                 type: 'integer',
 206                 renderer: Proxmox.Utils.render_uptime,
 207                 sortable: true,
 208                 width: 110
 209             },
 210             node: {
 211                 header: gettext('Node'),
 212                 type: 'string',
 213                 hidden: true,
 214                 sortable: true,
 215                 width: 110
 216             },
 217             storage: {
 218                 header: gettext('Storage'),
 219                 type: 'string',
 220                 hidden: true,
 221                 sortable: true,
 222                 width: 110
 223             },
 224             pool: {
 225                 header: gettext('Pool'),
 226                 type: 'string',
 227                 hidden: true,
 228                 sortable: true,
 229                 width: 110
 230             },
 231             hastate: {
 232                 header: gettext('HA State'),
 233                 type: 'string',
 234                 defaultValue: 'unmanaged',
 235                 hidden: true,
 236                 sortable: true
 237             },
 238             status: {
 239                 header: gettext('Status'),
 240                 type: 'string',
 241                 hidden: true,
 242                 sortable: true,
 243                 width: 110
 244             }
 245         };
 246
 247         var fields = [];
 248         var fieldNames = [];
 249         Ext.Object.each(field_defaults, function(key, value) {
 250             var field = {name: key, type: value.type};
 251             if (Ext.isDefined(value.convert)) {
 252                 field.convert = value.convert;
 253             }
 254
 255             if (Ext.isDefined(value.calculate)) {
 256                 field.calculate = value.calculate;
 257             }
 258
 259             if (Ext.isDefined(value.defaultValue)) {
 260                 field.defaultValue = value.defaultValue;
 261             }
 262
 263             fields.push(field);
 264             fieldNames.push(key);
 265         });
 266
 267         Ext.define('PVEResources', {
 268             extend: "Ext.data.Model",
 269             fields: fields,
 270             proxy: {
 271                 type: 'pve',
 272                 url: '/api2/json/cluster/resources'
 273             }
 274         });
 275
 276         Ext.define('PVETree', {
 277             extend: "Ext.data.Model",
 278             fields: fields,
 279             proxy: { type: 'memory' }
 280         });
 281
 282         Ext.apply(config, {
 283             storeid: 'PVEResources',
 284             model: 'PVEResources',
 285             defaultColumns: function() {
 286                 var res = [];
 287                 Ext.Object.each(field_defaults, function(field, info) {
 288                     var fi = Ext.apply({ dataIndex: field }, info);
 289                     res.push(fi);
 290                 });
 291                 return res;
 292             },
 293             fieldNames: fieldNames
 294         });
 295
 296         me.callParent([config]);
 297     }
 298 });