www/manager6/dc/Summary.js

   1 Ext.define('PVE.dc.Summary', {
   2     extend: 'Ext.panel.Panel',
   3     alias: 'widget.pveDcSummary',
   4
   5     scrollable: true,
   6
   7     bodyPadding: 5,
   8
   9     layout: 'column',
  10
  11     defaults: {
  12         padding: 5,
  13         columnWidth: 1,
  14     },
  15
  16     items: [
  17         {
  18             itemId: 'dcHealth',
  19             xtype: 'pveDcHealth',
  20         },
  21         {
  22             itemId: 'dcGuests',
  23             xtype: 'pveDcGuests',
  24         },
  25         {
  26             title: gettext('Resources'),
  27             xtype: 'panel',
  28             minHeight: 250,
  29             bodyPadding: 5,
  30             layout: 'hbox',
  31             defaults: {
  32                 xtype: 'proxmoxGauge',
  33                 flex: 1,
  34             },
  35             items: [
  36                 {
  37                     title: gettext('CPU'),
  38                     itemId: 'cpu',
  39                 },
  40                 {
  41                     title: gettext('Memory'),
  42                     itemId: 'memory',
  43                 },
  44                 {
  45                     title: gettext('Storage'),
  46                     itemId: 'storage',
  47                 },
  48             ],
  49         },
  50         {
  51             itemId: 'nodeview',
  52             xtype: 'pveDcNodeView',
  53             height: 250,
  54         },
  55         {
  56             title: gettext('Subscriptions'),
  57             height: 220,
  58             items: [
  59                 {
  60                     itemId: 'subscriptions',
  61                     xtype: 'pveHealthWidget',
  62                     userCls: 'pointer',
  63                     listeners: {
  64                         element: 'el',
  65                         click: function() {
  66                             if (this.component.userCls === 'pointer') {
  67                                 window.open('https://www.proxmox.com/en/proxmox-ve/pricing', '_blank');
  68                             }
  69                         },
  70                     },
  71                 },
  72             ],
  73         },
  74     ],
  75
  76     listeners: {
  77         resize: function(panel) {
  78             PVE.Utils.updateColumns(panel);
  79         },
  80     },
  81
  82     initComponent: function() {
  83         var me = this;
  84
  85         var rstore = Ext.create('Proxmox.data.UpdateStore', {
  86             interval: 3000,
  87             storeid: 'pve-cluster-status',
  88             model: 'pve-dc-nodes',
  89             proxy: {
  90                 type: 'proxmox',
  91                 url: "/api2/json/cluster/status",
  92             },
  93         });
  94
  95         var gridstore = Ext.create('Proxmox.data.DiffStore', {
  96             rstore: rstore,
  97             filters: {
  98                 property: 'type',
  99                 value: 'node',
 100             },
 101             sorters: {
 102                 property: 'id',
 103                 direction: 'ASC',
 104             },
 105         });
 106
 107         me.callParent();
 108
 109         me.getComponent('nodeview').setStore(gridstore);
 110
 111         var gueststatus = me.getComponent('dcGuests');
 112
 113         var cpustat = me.down('#cpu');
 114         var memorystat = me.down('#memory');
 115         var storagestat = me.down('#storage');
 116         var sp = Ext.state.Manager.getProvider();
 117
 118         me.mon(PVE.data.ResourceStore, 'load', function(curstore, results) {
 119             me.suspendLayout = true;
 120
 121             var cpu = 0;
 122             var maxcpu = 0;
 123
 124             var nodes = 0;
 125
 126             var memory = 0;
 127             var maxmem = 0;
 128
 129             var countedStorages = {};
 130             var used = 0;
 131             var total = 0;
 132             var usableStorages = {};
 133             var storages = sp.get('dash-storages') || '';
 134             storages.split(',').forEach(function(storage) {
 135                 if (storage !== '') {
 136                     usableStorages[storage] = true;
 137                 }
 138             });
 139
 140             var qemu = {
 141                 running: 0,
 142                 paused: 0,
 143                 stopped: 0,
 144                 template: 0,
 145             };
 146             var lxc = {
 147                 running: 0,
 148                 paused: 0,
 149                 stopped: 0,
 150                 template: 0,
 151             };
 152             var error = 0;
 153
 154             var i;
 155
 156             for (i = 0; i < results.length; i++) {
 157                 var item = results[i];
 158                 switch (item.data.type) {
 159                     case 'node':
 160                         cpu += item.data.cpu * item.data.maxcpu;
 161                         maxcpu += item.data.maxcpu || 0;
 162                         memory += item.data.mem || 0;
 163                         maxmem += item.data.maxmem || 0;
 164                         nodes++;
 165
 166                         // update grid also
 167                         var griditem = gridstore.getById(item.data.id);
 168                         if (griditem) {
 169                             griditem.set('cpuusage', item.data.cpu);
 170                             var max = item.data.maxmem || 1;
 171                             var val = item.data.mem || 0;
 172                             griditem.set('memoryusage', val/max);
 173                             griditem.set('uptime', item.data.uptime);
 174                             griditem.commit(); //else it marks the fields as dirty
 175                         }
 176                         break;
 177                     case 'storage':
 178                         if (!Ext.Object.isEmpty(usableStorages)) {
 179                             if (usableStorages[item.data.id] === true) {
 180                                 used += item.data.disk;
 181                                 total += item.data.maxdisk;
 182                             }
 183                             break;
 184                         }
 185                         if (!countedStorages[item.data.storage] ||
 186                             !item.data.shared && !countedStorages[item.data.id]) {
 187                             used += item.data.disk;
 188                             total += item.data.maxdisk;
 189
 190                             countedStorages[item.data.storage === 'local'?item.data.id:item.data.storage] = true;
 191                         }
 192                         break;
 193                     case 'qemu':
 194                         qemu[item.data.template ? 'template' : item.data.status]++;
 195                         if (item.data.hastate === 'error') {
 196                             error++;
 197                         }
 198                         break;
 199                     case 'lxc':
 200                         lxc[item.data.template ? 'template' : item.data.status]++;
 201                         if (item.data.hastate === 'error') {
 202                             error++;
 203                         }
 204                         break;
 205                     default: break;
 206                 }
 207             }
 208
 209             var text = Ext.String.format(gettext('of {0} CPU(s)'), maxcpu);
 210             cpustat.updateValue(cpu/maxcpu, text);
 211
 212             text = Ext.String.format(gettext('{0} of {1}'), Proxmox.Utils.render_size(memory), Proxmox.Utils.render_size(maxmem));
 213             memorystat.updateValue(memory/maxmem, text);
 214
 215             text = Ext.String.format(gettext('{0} of {1}'), Proxmox.Utils.render_size(used), Proxmox.Utils.render_size(total));
 216             storagestat.updateValue(used/total, text);
 217
 218             gueststatus.updateValues(qemu, lxc, error);
 219
 220             me.suspendLayout = false;
 221             me.updateLayout(true);
 222         });
 223
 224         var dcHealth = me.getComponent('dcHealth');
 225         me.mon(rstore, 'load', dcHealth.updateStatus, dcHealth);
 226
 227         var subs = me.down('#subscriptions');
 228         me.mon(rstore, 'load', function(store, records, success) {
 229             var i;
 230             var level;
 231             var mixed = false;
 232             for (i = 0; i < records.length; i++) {
 233                 if (records[i].get('type') !== 'node') {
 234                     continue;
 235                 }
 236                 var node = records[i];
 237                 if (node.get('status') === 'offline') {
 238                     continue;
 239                 }
 240
 241                 var curlevel = node.get('level');
 242
 243                 if (curlevel === '') { // no subscription trumps all, set and break
 244                     level = '';
 245                     break;
 246                 }
 247
 248                 if (level === undefined) { // save level
 249                     level = curlevel;
 250                 } else if (level !== curlevel) { // detect different levels
 251                     mixed = true;
 252                 }
 253             }
 254
 255             var data = {
 256                 title: Proxmox.Utils.unknownText,
 257                 text: Proxmox.Utils.unknownText,
 258                 iconCls: PVE.Utils.get_health_icon(undefined, true),
 259             };
 260             if (level === '') {
 261                 data = {
 262                     title: gettext('No Subscription'),
 263                     iconCls: PVE.Utils.get_health_icon('critical', true),
 264                     text: gettext('You have at least one node without subscription.'),
 265                 };
 266                 subs.setUserCls('pointer');
 267             } else if (mixed) {
 268                 data = {
 269                     title: gettext('Mixed Subscriptions'),
 270                     iconCls: PVE.Utils.get_health_icon('warning', true),
 271                     text: gettext('Warning: Your subscription levels are not the same.'),
 272                 };
 273                 subs.setUserCls('pointer');
 274             } else if (level) {
 275                 data = {
 276                     title: PVE.Utils.render_support_level(level),
 277                     iconCls: PVE.Utils.get_health_icon('good', true),
 278                     text: gettext('Your subscription status is valid.'),
 279                 };
 280                 subs.setUserCls('');
 281             }
 282
 283             subs.setData(data);
 284         });
 285
 286         me.on('destroy', function() {
 287             rstore.stopUpdate();
 288         });
 289
 290         me.mon(sp, 'statechange', function(provider, key, value) {
 291             if (key !== 'summarycolumns') {
 292                 return;
 293             }
 294             PVE.Utils.updateColumns(me);
 295         });
 296
 297         rstore.startUpdate();
 298     },
 299
 300 });