www/manager6/qemu/HardwareView.js

   1 Ext.define('PVE.qemu.HardwareView', {
   2     extend: 'Proxmox.grid.PendingObjectGrid',
   3     alias: ['widget.PVE.qemu.HardwareView'],
   4
   5     onlineHelp: 'qm_virtual_machines_settings',
   6
   7     renderKey: function(key, metaData, rec, rowIndex, colIndex, store) {
   8         var me = this;
   9         var rows = me.rows;
  10         var rowdef = rows[key] || {};
  11
  12         metaData.tdAttr = "valign=middle";
  13
  14         if (rowdef.tdCls) {
  15             metaData.tdCls = rowdef.tdCls;
  16             if (rowdef.tdCls == 'pve-itype-icon-storage') {
  17                 var value = me.getObjectValue(key, '', true);
  18                 if (value.match(/vm-.*-cloudinit/)) {
  19                     metaData.tdCls = 'pve-itype-icon-cloud';
  20                     return rowdef.cloudheader;
  21                 } else if (value.match(/media=cdrom/)) {
  22                     metaData.tdCls = 'pve-itype-icon-cdrom';
  23                     return rowdef.cdheader;
  24                 }
  25             }
  26         }
  27         return rowdef.header || key;
  28     },
  29
  30     initComponent : function() {
  31         var me = this;
  32         var i, confid;
  33
  34         var nodename = me.pveSelNode.data.node;
  35         if (!nodename) {
  36             throw "no node name specified";
  37         }
  38
  39         var vmid = me.pveSelNode.data.vmid;
  40         if (!vmid) {
  41             throw "no VM ID specified";
  42         }
  43
  44         var caps = Ext.state.Manager.get('GuiCap');
  45
  46         var rows = {
  47             memory: {
  48                 header: gettext('Memory'),
  49                 editor: caps.vms['VM.Config.Memory'] ? 'PVE.qemu.MemoryEdit' : undefined,
  50                 never_delete: true,
  51                 defaultValue: '512',
  52                 tdCls: 'pve-itype-icon-memory',
  53                 renderer: function(value, metaData, record) {
  54                     var balloon =  me.getObjectValue('balloon');
  55                     if (balloon) {
  56                         return Proxmox.Utils.format_size(balloon*1024*1024) + "/" +
  57                             Proxmox.Utils.format_size(value*1024*1024);
  58
  59                     }
  60                     return Proxmox.Utils.format_size(value*1024*1024);
  61                 }
  62             },
  63             sockets: {
  64                 header: gettext('Processors'),
  65                 never_delete: true,
  66                 editor: (caps.vms['VM.Config.CPU'] || caps.vms['VM.Config.HWType']) ?
  67                     'PVE.qemu.ProcessorEdit' : undefined,
  68                 tdCls: 'pve-itype-icon-processor',
  69                 defaultValue: '1',
  70                 multiKey: ['sockets', 'cpu', 'cores', 'numa', 'vcpus', 'cpulimit', 'cpuunits'],
  71                 renderer: function(value, metaData, record, rowIndex, colIndex, store, pending) {
  72
  73                     var sockets = me.getObjectValue('sockets', 1, pending);
  74                     var model = me.getObjectValue('cpu', undefined, pending);
  75                     var cores = me.getObjectValue('cores', 1, pending);
  76                     var numa = me.getObjectValue('numa', undefined, pending);
  77                     var vcpus = me.getObjectValue('vcpus', undefined, pending);
  78                     var cpulimit = me.getObjectValue('cpulimit', undefined, pending);
  79                     var cpuunits = me.getObjectValue('cpuunits', undefined, pending);
  80
  81                     var res = Ext.String.format('{0} ({1} sockets, {2} cores)',
  82                         sockets*cores, sockets, cores);
  83
  84                     if (model) {
  85                         res += ' [' + model + ']';
  86                     }
  87
  88                     if (numa) {
  89                         res += ' [numa=' + numa +']';
  90                     }
  91
  92                     if (vcpus) {
  93                         res += ' [vcpus=' + vcpus +']';
  94                     }
  95
  96                     if (cpulimit) {
  97                         res += ' [cpulimit=' + cpulimit +']';
  98                     }
  99
 100                     if (cpuunits) {
 101                         res += ' [cpuunits=' + cpuunits +']';
 102                     }
 103
 104                     return res;
 105                 }
 106             },
 107             keyboard: {
 108                 header: gettext('Keyboard Layout'),
 109                 never_delete: true,
 110                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.KeyboardEdit' : undefined,
 111                 tdCls: 'pve-itype-icon-keyboard',
 112                 defaultValue: '',
 113                 renderer: PVE.Utils.render_kvm_language
 114             },
 115             vga: {
 116                 header: gettext('Display'),
 117                 editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.DisplayEdit' : undefined,
 118                 never_delete: true,
 119                 tdCls: 'pve-itype-icon-display',
 120                 defaultValue: '',
 121                 renderer: PVE.Utils.render_kvm_vga_driver
 122             },
 123             cores: {
 124                 visible: false
 125             },
 126             cpu: {
 127                 visible: false
 128             },
 129             numa: {
 130                 visible: false
 131             },
 132             balloon: {
 133                 visible: false
 134             },
 135             hotplug: {
 136                 visible: false
 137             },
 138             vcpus: {
 139                 visible: false
 140             },
 141             cpuunits: {
 142                 visible: false
 143             },
 144             cpulimit: {
 145                 visible: false
 146             },
 147             bios: {
 148                 visible: false
 149             }
 150
 151         };
 152
 153         PVE.Utils.forEachBus(undefined, function(type, id) {
 154             var confid = type + id;
 155             rows[confid] = {
 156                 group: 1,
 157                 tdCls: 'pve-itype-icon-storage',
 158                 editor: 'PVE.qemu.HDEdit',
 159                 never_delete: caps.vms['VM.Config.Disk'] ? false : true,
 160                 header: gettext('Hard Disk') + ' (' + confid +')',
 161                 cdheader: gettext('CD/DVD Drive') + ' (' + confid +')',
 162                 cloudheader: gettext('CloudInit Drive') + ' (' + confid + ')'
 163             };
 164         });
 165         for (i = 0; i < 32; i++) {
 166             confid = "net" + i.toString();
 167             rows[confid] = {
 168                 group: 2,
 169                 tdCls: 'pve-itype-icon-network',
 170                 editor: caps.vms['VM.Config.Network'] ? 'PVE.qemu.NetworkEdit' : undefined,
 171                 never_delete: caps.vms['VM.Config.Network'] ? false : true,
 172                 header: gettext('Network Device') + ' (' + confid +')'
 173             };
 174         }
 175         rows.efidisk0 = {
 176             group: 3,
 177             tdCls: 'pve-itype-icon-storage',
 178             editor: null,
 179             never_delete: caps.vms['VM.Config.Disk'] ? false : true,
 180             header: gettext('EFI Disk')
 181         };
 182         for (i = 0; i < 5; i++) {
 183             confid = "usb" + i.toString();
 184             rows[confid] = {
 185                 group: 4,
 186                 tdCls: 'pve-itype-icon-usb',
 187                 editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.USBEdit' : undefined,
 188                 never_delete: caps.nodes['Sys.Console'] ? false : true,
 189                 header: gettext('USB Device') + ' (' + confid + ')'
 190             };
 191         }
 192         for (i = 0; i < 4; i++) {
 193             confid = "hostpci" + i.toString();
 194             rows[confid] = {
 195                 group: 5,
 196                 tdCls: 'pve-itype-icon-pci',
 197                 never_delete: caps.nodes['Sys.Console'] ? false : true,
 198                 header: gettext('PCI Device') + ' (' + confid + ')'
 199             };
 200         }
 201         for (i = 0; i < 4; i++) {
 202             confid = "serial" + i.toString();
 203             rows[confid] = {
 204                 group: 6,
 205                 tdCls: 'pve-itype-icon-serial',
 206                 never_delete: caps.nodes['Sys.Console'] ? false : true,
 207                 header: gettext('Serial Port') + ' (' + confid + ')'
 208             };
 209         }
 210         for (i = 0; i < 8; i++) {
 211             rows["unused" + i.toString()] = {
 212                 group: 99,
 213                 tdCls: 'pve-itype-icon-storage',
 214                 editor: caps.vms['VM.Config.Disk'] ? 'PVE.qemu.HDEdit' : undefined,
 215                 header: gettext('Unused Disk') + ' ' + i.toString()
 216             };
 217         }
 218
 219         var sorterFn = function(rec1, rec2) {
 220             var v1 = rec1.data.key;
 221             var v2 = rec2.data.key;
 222             var g1 = rows[v1].group || 0;
 223             var g2 = rows[v2].group || 0;
 224
 225             return (g1 !== g2) ?
 226                 (g1 > g2 ? 1 : -1) : (v1 > v2 ? 1 : (v1 < v2 ? -1 : 0));
 227         };
 228
 229         var reload = function() {
 230             me.rstore.load();
 231         };
 232
 233         var baseurl = 'nodes/' + nodename + '/qemu/' + vmid + '/config';
 234
 235         var sm = Ext.create('Ext.selection.RowModel', {});
 236
 237         var run_editor = function() {
 238             var rec = sm.getSelection()[0];
 239             if (!rec) {
 240                 return;
 241             }
 242
 243             var rowdef = rows[rec.data.key];
 244             if (!rowdef.editor) {
 245                 return;
 246             }
 247
 248             var editor = rowdef.editor;
 249             if (rowdef.tdCls == 'pve-itype-icon-storage') {
 250                 var value = me.getObjectValue(rec.data.key, '', true);
 251                 if (value.match(/vm-.*-cloudinit/)) {
 252                     return;
 253                 } else if (value.match(/media=cdrom/)) {
 254                     editor = 'PVE.qemu.CDEdit';
 255                 }
 256             }
 257
 258             var win;
 259
 260             if (Ext.isString(editor)) {
 261                 win = Ext.create(editor, {
 262                     pveSelNode: me.pveSelNode,
 263                     confid: rec.data.key,
 264                     url: '/api2/extjs/' + baseurl
 265                 });
 266             } else {
 267                 var config = Ext.apply({
 268                     pveSelNode: me.pveSelNode,
 269                     confid: rec.data.key,
 270                     url: '/api2/extjs/' + baseurl
 271                 }, rowdef.editor);
 272                 win = Ext.createWidget(rowdef.editor.xtype, config);
 273                 win.load();
 274             }
 275
 276             win.show();
 277             win.on('destroy', reload);
 278         };
 279
 280         var run_resize = function() {
 281             var rec = sm.getSelection()[0];
 282             if (!rec) {
 283                 return;
 284             }
 285
 286             var win = Ext.create('PVE.window.HDResize', {
 287                 disk: rec.data.key,
 288                 nodename: nodename,
 289                 vmid: vmid
 290             });
 291
 292             win.show();
 293
 294             win.on('destroy', reload);
 295         };
 296
 297         var run_move = function() {
 298             var rec = sm.getSelection()[0];
 299             if (!rec) {
 300                 return;
 301             }
 302
 303             var win = Ext.create('PVE.window.HDMove', {
 304                 disk: rec.data.key,
 305                 nodename: nodename,
 306                 vmid: vmid
 307             });
 308
 309             win.show();
 310
 311             win.on('destroy', reload);
 312         };
 313
 314         var edit_btn = new Proxmox.button.Button({
 315             text: gettext('Edit'),
 316             selModel: sm,
 317             disabled: true,
 318             handler: run_editor
 319         });
 320
 321         var resize_btn = new Proxmox.button.Button({
 322             text: gettext('Resize disk'),
 323             selModel: sm,
 324             disabled: true,
 325             handler: run_resize
 326         });
 327
 328         var move_btn = new Proxmox.button.Button({
 329             text: gettext('Move disk'),
 330             selModel: sm,
 331             disabled: true,
 332             handler: run_move
 333         });
 334
 335         var remove_btn = new Proxmox.button.Button({
 336             text: gettext('Remove'),
 337             defaultText: gettext('Remove'),
 338             altText: gettext('Detach'),
 339             selModel: sm,
 340             disabled: true,
 341             dangerous: true,
 342             confirmMsg: function(rec) {
 343                 var warn = gettext('Are you sure you want to remove entry {0}');
 344                 if (this.text === this.altText) {
 345                     warn = gettext('Are you sure you want to detach entry {0}');
 346                 }
 347
 348                 var entry = rec.data.key;
 349                 var msg = Ext.String.format(warn, "'"
 350                     + me.renderKey(entry, {}, rec) + "'");
 351
 352                 if (entry.match(/^unused\d+$/)) {
 353                     msg += " " + gettext('This will permanently erase all data.');
 354                 }
 355
 356                 return msg;
 357             },
 358             handler: function(b, e, rec) {
 359                 Proxmox.Utils.API2Request({
 360                     url: '/api2/extjs/' + baseurl,
 361                     waitMsgTarget: me,
 362                     method: 'PUT',
 363                     params: {
 364                         'delete': rec.data.key
 365                     },
 366                     callback: function() {
 367                         reload();
 368                     },
 369                     failure: function (response, opts) {
 370                         Ext.Msg.alert('Error', response.htmlStatus);
 371                     }
 372                 });
 373             },
 374             listeners: {
 375                 render: function(btn) {
 376                     // hack: calculate an optimal button width on first display
 377                     // to prevent the whole toolbar to move when we switch
 378                     // between the "Remove" and "Detach" labels
 379                     var def = btn.getSize().width;
 380
 381                     btn.setText(btn.altText);
 382                     var alt = btn.getSize().width;
 383
 384                     btn.setText(btn.defaultText);
 385
 386                     var optimal = alt > def ? alt : def;
 387                     btn.setSize({ width: optimal });
 388                 }
 389             }
 390         });
 391
 392         var revert_btn = new Proxmox.button.Button({
 393             text: gettext('Revert'),
 394             selModel: sm,
 395             disabled: true,
 396             handler: function(b, e, rec) {
 397                 var rowdef = me.rows[rec.data.key] || {};
 398                 var keys = rowdef.multiKey ||  [ rec.data.key ];
 399                 var revert = keys.join(',');
 400                 Proxmox.Utils.API2Request({
 401                     url: '/api2/extjs/' + baseurl,
 402                     waitMsgTarget: me,
 403                     method: 'PUT',
 404                     params: {
 405                         'revert': revert
 406                     },
 407                     callback: function() {
 408                         reload();
 409                     },
 410                     failure: function (response, opts) {
 411                         Ext.Msg.alert('Error',response.htmlStatus);
 412                     }
 413                 });
 414             }
 415         });
 416
 417         var efidisk_menuitem = Ext.create('Ext.menu.Item',{
 418             text: gettext('EFI Disk'),
 419             iconCls: 'pve-itype-icon-storage',
 420             disabled: !caps.vms['VM.Config.Disk'],
 421             handler: function() {
 422
 423                 var rstoredata = me.rstore.getData().map;
 424                 // check if ovmf is configured
 425                 if (rstoredata.bios && rstoredata.bios.data.value === 'ovmf') {
 426                     var win = Ext.create('PVE.qemu.EFIDiskEdit', {
 427                         url: '/api2/extjs/' + baseurl,
 428                         pveSelNode: me.pveSelNode
 429                     });
 430                     win.on('destroy', reload);
 431                     win.show();
 432                 } else {
 433                     Ext.Msg.alert('Error',gettext('Please select OVMF(UEFI) as BIOS first.'));
 434                 }
 435
 436             }
 437         });
 438
 439         var set_button_status = function() {
 440             var sm = me.getSelectionModel();
 441             var rec = sm.getSelection()[0];
 442
 443             // disable button when we have an efidisk already
 444             // disable is ok in this case, because you can instantly
 445             // see that there is already one
 446             efidisk_menuitem.setDisabled(me.rstore.getData().map.efidisk0 !== undefined);
 447             // en/disable usb add button
 448             var count = 0;
 449             var hasCloudInit = false;
 450             me.rstore.getData().items.forEach(function(item){
 451                 if (/^usb\d+/.test(item.id)) {
 452                     count++;
 453                 }
 454                 if (!hasCloudInit && /vm-.*-cloudinit/.test(item.data.value)) {
 455                     hasCloudInit = true;
 456                 }
 457             });
 458             me.down('#addusb').setDisabled((count >= 5));
 459             me.down('#addci').setDisabled(hasCloudInit);
 460
 461             if (!rec) {
 462                 remove_btn.disable();
 463                 edit_btn.disable();
 464                 resize_btn.disable();
 465                 move_btn.disable();
 466                 revert_btn.disable();
 467                 return;
 468             }
 469             var key = rec.data.key;
 470             var value = rec.data.value;
 471             var rowdef = rows[key];
 472
 473             var pending = rec.data['delete'] || me.hasPendingChanges(key);
 474             var isUsedDisk = !key.match(/^unused\d+/) &&
 475                 rowdef.tdCls == 'pve-itype-icon-storage' &&
 476                 (value && !value.match(/media=cdrom/));
 477
 478             var isCloudInit = (value && value.toString().match(/vm-.*-cloudinit/));
 479
 480             var isEfi = (key === 'efidisk0');
 481
 482             remove_btn.setDisabled(rec.data['delete'] || (rowdef.never_delete === true));
 483             remove_btn.setText((isUsedDisk && !isCloudInit) ? remove_btn.altText : remove_btn.defaultText);
 484
 485             edit_btn.setDisabled(rec.data['delete'] || !rowdef.editor || isCloudInit);
 486
 487             resize_btn.setDisabled(pending || !isUsedDisk);
 488
 489             move_btn.setDisabled(pending || !isUsedDisk);
 490
 491             revert_btn.setDisabled(!pending);
 492
 493         };
 494
 495         Ext.apply(me, {
 496             url: '/api2/json/' + 'nodes/' + nodename + '/qemu/' + vmid + '/pending',
 497             interval: 5000,
 498             selModel: sm,
 499             run_editor: run_editor,
 500             tbar: [
 501                 {
 502                     text: gettext('Add'),
 503                     menu: new Ext.menu.Menu({
 504                         items: [
 505                             {
 506                                 text: gettext('Hard Disk'),
 507                                 iconCls: 'pve-itype-icon-storage',
 508                                 disabled: !caps.vms['VM.Config.Disk'],
 509                                 handler: function() {
 510                                     var win = Ext.create('PVE.qemu.HDEdit', {
 511                                         url: '/api2/extjs/' + baseurl,
 512                                         pveSelNode: me.pveSelNode
 513                                     });
 514                                     win.on('destroy', reload);
 515                                     win.show();
 516                                 }
 517                             },
 518                             {
 519                                 text: gettext('CD/DVD Drive'),
 520                                 iconCls: 'pve-itype-icon-cdrom',
 521                                 disabled: !caps.vms['VM.Config.Disk'],
 522                                 handler: function() {
 523                                     var win = Ext.create('PVE.qemu.CDEdit', {
 524                                         url: '/api2/extjs/' + baseurl,
 525                                         pveSelNode: me.pveSelNode
 526                                     });
 527                                     win.on('destroy', reload);
 528                                     win.show();
 529                                 }
 530                             },
 531                             {
 532                                 text: gettext('Network Device'),
 533                                 iconCls: 'pve-itype-icon-network',
 534                                 disabled: !caps.vms['VM.Config.Network'],
 535                                 handler: function() {
 536                                     var win = Ext.create('PVE.qemu.NetworkEdit', {
 537                                         url: '/api2/extjs/' + baseurl,
 538                                         pveSelNode: me.pveSelNode
 539                                     });
 540                                     win.on('destroy', reload);
 541                                     win.show();
 542                                 }
 543                             },
 544                             efidisk_menuitem,
 545                             {
 546                                 text: gettext('USB Device'),
 547                                 itemId: 'addusb',
 548                                 iconCls: 'pve-itype-icon-usb',
 549                                 disabled: !caps.nodes['Sys.Console'],
 550                                 handler: function() {
 551                                     var win = Ext.create('PVE.qemu.USBEdit', {
 552                                         url: '/api2/extjs/' + baseurl,
 553                                         pveSelNode: me.pveSelNode
 554                                     });
 555                                     win.on('destroy', reload);
 556                                     win.show();
 557                                 }
 558                             },
 559                             {
 560                                 text: gettext('CloudInit Drive'),
 561                                 itemId: 'addci',
 562                                 iconCls: 'pve-itype-icon-cloud',
 563                                 disabled: !caps.nodes['Sys.Console'],
 564                                 handler: function() {
 565                                     var win = Ext.create('PVE.qemu.CIDriveEdit', {
 566                                         url: '/api2/extjs/' + baseurl,
 567                                         pveSelNode: me.pveSelNode
 568                                     });
 569                                     win.on('destroy', reload);
 570                                     win.show();
 571                                 }
 572                             }
 573                         ]
 574                     })
 575                 },
 576                 remove_btn,
 577                 edit_btn,
 578                 resize_btn,
 579                 move_btn,
 580                 revert_btn
 581             ],
 582             rows: rows,
 583             sorterFn: sorterFn,
 584             listeners: {
 585                 itemdblclick: run_editor,
 586                 selectionchange: set_button_status
 587             }
 588         });
 589
 590         me.callParent();
 591
 592         me.on('activate', me.rstore.startUpdate);
 593         me.on('destroy', me.rstore.stopUpdate);
 594
 595         me.mon(me.rstore, 'refresh', function() {
 596             set_button_status();
 597         });
 598     }
 599 });