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