www/manager6/data/ResourceStore.js

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