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         var iconCls = rowdef.iconCls;
  12         var icon = '';
  13         var txt = rowdef.header || key;
  14
  15         metaData.tdAttr = "valign=middle";
  16
  17         if (rowdef.isOnStorageBus) {
  18             var value = me.getObjectValue(key, '', false);
  19             if (value === '') {
  20                 value = me.getObjectValue(key, '', true);
  21             }
  22             if (value.match(/vm-.*-cloudinit/)) {
  23                 iconCls = 'cloud';
  24                 txt = rowdef.cloudheader;
  25             } else if (value.match(/media=cdrom/)) {
  26                 metaData.tdCls = 'pve-itype-icon-cdrom';
  27                 return rowdef.cdheader;
  28             }
  29         }
  30
  31         if (rowdef.tdCls) {
  32             metaData.tdCls = rowdef.tdCls;
  33         } else if (iconCls) {
  34             icon = "<i class='pve-grid-fa fa fa-fw fa-" + iconCls + "'></i>";
  35             metaData.tdCls += " pve-itype-fa";
  36         }
  37
  38         // only return icons in grid but not remove dialog
  39         if (rowIndex !== undefined) {
  40             return icon + txt;
  41         } else {
  42             return txt;
  43         }
  44     },
  45
  46     initComponent: function() {
  47         var me = this;
  48
  49         const { node: nodename, vmid } = me.pveSelNode.data;
  50         if (!nodename) {
  51             throw "no node name specified";
  52         } else if (!vmid) {
  53             throw "no VM ID specified";
  54         }
  55
  56         const caps = Ext.state.Manager.get('GuiCap');
  57         const diskCap = caps.vms['VM.Config.Disk'];
  58         const cdromCap = caps.vms['VM.Config.CDROM'];
  59
  60         let isCloudInitKey = v => v && v.toString().match(/vm-.*-cloudinit/);
  61
  62         let rows = {
  63             memory: {
  64                 header: gettext('Memory'),
  65                 editor: caps.vms['VM.Config.Memory'] ? 'PVE.qemu.MemoryEdit' : undefined,
  66                 never_delete: true,
  67                 defaultValue: '512',
  68                 tdCls: 'pve-itype-icon-memory',
  69                 group: 2,
  70                 multiKey: ['memory', 'balloon', 'shares'],
  71                 renderer: function(value, metaData, record, ri, ci, store, pending) {
  72                     var res = '';
  73
  74                     var max = me.getObjectValue('memory', 512, pending);
  75                     var balloon = me.getObjectValue('balloon', undefined, pending);
  76                     var shares = me.getObjectValue('shares', undefined, pending);
  77
  78                     res = Proxmox.Utils.format_size(max*1024*1024);
  79
  80                     if (balloon !== undefined && balloon > 0) {
  81                         res = Proxmox.Utils.format_size(balloon*1024*1024) + "/" + res;
  82
  83                         if (shares) {
  84                             res += ' [shares=' + shares +']';
  85                         }
  86                     } else if (balloon === 0) {
  87                         res += ' [balloon=0]';
  88                     }
  89                     return res;
  90                 },
  91             },
  92             sockets: {
  93                 header: gettext('Processors'),
  94                 never_delete: true,
  95                 editor: caps.vms['VM.Config.CPU'] || caps.vms['VM.Config.HWType']
  96                     ? 'PVE.qemu.ProcessorEdit' : undefined,
  97                 tdCls: 'pve-itype-icon-cpu',
  98                 group: 3,
  99                 defaultValue: '1',
 100                 multiKey: ['sockets', 'cpu', 'cores', 'numa', 'vcpus', 'cpulimit', 'cpuunits'],
 101                 renderer: function(value, metaData, record, rowIndex, colIndex, store, pending) {
 102                     var sockets = me.getObjectValue('sockets', 1, pending);
 103                     var model = me.getObjectValue('cpu', undefined, pending);
 104                     var cores = me.getObjectValue('cores', 1, pending);
 105                     var numa = me.getObjectValue('numa', undefined, pending);
 106                     var vcpus = me.getObjectValue('vcpus', undefined, pending);
 107                     var cpulimit = me.getObjectValue('cpulimit', undefined, pending);
 108                     var cpuunits = me.getObjectValue('cpuunits', undefined, pending);
 109
 110                     let res = Ext.String.format(
 111                         '{0} ({1} sockets, {2} cores)', sockets * cores, sockets, cores);
 112
 113                     if (model) {
 114                         res += ' [' + model + ']';
 115                     }
 116                     if (numa) {
 117                         res += ' [numa=' + numa +']';
 118                     }
 119                     if (vcpus) {
 120                         res += ' [vcpus=' + vcpus +']';
 121                     }
 122                     if (cpulimit) {
 123                         res += ' [cpulimit=' + cpulimit +']';
 124                     }
 125                     if (cpuunits) {
 126                         res += ' [cpuunits=' + cpuunits +']';
 127                     }
 128
 129                     return res;
 130                 },
 131             },
 132             bios: {
 133                 header: 'BIOS',
 134                 group: 4,
 135                 never_delete: true,
 136                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.BiosEdit' : undefined,
 137                 defaultValue: '',
 138                 iconCls: 'microchip',
 139                 renderer: PVE.Utils.render_qemu_bios,
 140             },
 141             vga: {
 142                 header: gettext('Display'),
 143                 editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.DisplayEdit' : undefined,
 144                 never_delete: true,
 145                 iconCls: 'desktop',
 146                 group: 5,
 147                 defaultValue: '',
 148                 renderer: PVE.Utils.render_kvm_vga_driver,
 149             },
 150             machine: {
 151                 header: gettext('Machine'),
 152                 editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.MachineEdit' : undefined,
 153                 iconCls: 'cogs',
 154                 never_delete: true,
 155                 group: 6,
 156                 defaultValue: '',
 157                 renderer: function(value, metaData, record, rowIndex, colIndex, store, pending) {
 158                     let ostype = me.getObjectValue('ostype', undefined, pending);
 159                     if (PVE.Utils.is_windows(ostype) &&
 160                         (!value || value === 'pc' || value === 'q35')) {
 161                         return value === 'q35' ? 'pc-q35-5.1' : 'pc-i440fx-5.1';
 162                     }
 163                     return PVE.Utils.render_qemu_machine(value);
 164                 },
 165             },
 166             scsihw: {
 167                 header: gettext('SCSI Controller'),
 168                 iconCls: 'database',
 169                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.ScsiHwEdit' : undefined,
 170                 renderer: PVE.Utils.render_scsihw,
 171                 group: 7,
 172                 never_delete: true,
 173                 defaultValue: '',
 174             },
 175             vmstate: {
 176                 header: gettext('Hibernation VM State'),
 177                 iconCls: 'download',
 178                 del_extra_msg: gettext('The saved VM state will be permanently lost.'),
 179                 group: 100,
 180             },
 181             cores: {
 182                 visible: false,
 183             },
 184             cpu: {
 185                 visible: false,
 186             },
 187             numa: {
 188                 visible: false,
 189             },
 190             balloon: {
 191                 visible: false,
 192             },
 193             hotplug: {
 194                 visible: false,
 195             },
 196             vcpus: {
 197                 visible: false,
 198             },
 199             cpuunits: {
 200                 visible: false,
 201             },
 202             cpulimit: {
 203                 visible: false,
 204             },
 205             shares: {
 206                 visible: false,
 207             },
 208             ostype: {
 209                 visible: false,
 210             },
 211         };
 212
 213         PVE.Utils.forEachBus(undefined, function(type, id) {
 214             let confid = type + id;
 215             rows[confid] = {
 216                 group: 10,
 217                 iconCls: 'hdd-o',
 218                 editor: 'PVE.qemu.HDEdit',
 219                 isOnStorageBus: true,
 220                 header: gettext('Hard Disk') + ' (' + confid +')',
 221                 cdheader: gettext('CD/DVD Drive') + ' (' + confid +')',
 222                 cloudheader: gettext('CloudInit Drive') + ' (' + confid + ')',
 223             };
 224         });
 225         for (let i = 0; i < PVE.Utils.hardware_counts.net; i++) {
 226             let confid = "net" + i.toString();
 227             rows[confid] = {
 228                 group: 15,
 229                 order: i,
 230                 iconCls: 'exchange',
 231                 editor: caps.vms['VM.Config.Network'] ? 'PVE.qemu.NetworkEdit' : undefined,
 232                 never_delete: !caps.vms['VM.Config.Network'],
 233                 header: gettext('Network Device') + ' (' + confid +')',
 234             };
 235         }
 236         rows.efidisk0 = {
 237             group: 20,
 238             iconCls: 'hdd-o',
 239             editor: null,
 240             never_delete: !caps.vms['VM.Config.Disk'],
 241             header: gettext('EFI Disk'),
 242         };
 243         rows.tpmstate0 = {
 244             group: 22,
 245             iconCls: 'hdd-o',
 246             editor: null,
 247             never_delete: !caps.vms['VM.Config.Disk'],
 248             header: gettext('TPM State'),
 249         };
 250         for (let i = 0; i < PVE.Utils.hardware_counts.usb; i++) {
 251             let confid = "usb" + i.toString();
 252             rows[confid] = {
 253                 group: 25,
 254                 order: i,
 255                 iconCls: 'usb',
 256                 editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.USBEdit' : undefined,
 257                 never_delete: !caps.nodes['Sys.Console'],
 258                 header: gettext('USB Device') + ' (' + confid + ')',
 259             };
 260         }
 261         for (let i = 0; i < PVE.Utils.hardware_counts.hostpci; i++) {
 262             let confid = "hostpci" + i.toString();
 263             rows[confid] = {
 264                 group: 30,
 265                 order: i,
 266                 tdCls: 'pve-itype-icon-pci',
 267                 never_delete: !caps.nodes['Sys.Console'],
 268                 editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.PCIEdit' : undefined,
 269                 header: gettext('PCI Device') + ' (' + confid + ')',
 270             };
 271         }
 272         for (let i = 0; i < PVE.Utils.hardware_counts.serial; i++) {
 273             let confid = "serial" + i.toString();
 274             rows[confid] = {
 275                 group: 35,
 276                 order: i,
 277                 tdCls: 'pve-itype-icon-serial',
 278                 never_delete: !caps.nodes['Sys.Console'],
 279                 header: gettext('Serial Port') + ' (' + confid + ')',
 280             };
 281         }
 282         rows.audio0 = {
 283             group: 40,
 284             iconCls: 'volume-up',
 285             editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.AudioEdit' : undefined,
 286             never_delete: !caps.vms['VM.Config.HWType'],
 287             header: gettext('Audio Device'),
 288         };
 289         for (let i = 0; i < 256; i++) {
 290             rows["unused" + i.toString()] = {
 291                 group: 99,
 292                 order: i,
 293                 iconCls: 'hdd-o',
 294                 del_extra_msg: gettext('This will permanently erase all data.'),
 295                 editor: caps.vms['VM.Config.Disk'] ? 'PVE.qemu.HDEdit' : undefined,
 296                 header: gettext('Unused Disk') + ' ' + i.toString(),
 297             };
 298         }
 299         rows.rng0 = {
 300             group: 45,
 301             tdCls: 'pve-itype-icon-die',
 302             editor: caps.nodes['Sys.Console'] ? 'PVE.qemu.RNGEdit' : undefined,
 303             never_delete: !caps.nodes['Sys.Console'],
 304             header: gettext("VirtIO RNG"),
 305         };
 306
 307         var sorterFn = function(rec1, rec2) {
 308             var v1 = rec1.data.key;
 309             var v2 = rec2.data.key;
 310             var g1 = rows[v1].group || 0;
 311             var g2 = rows[v2].group || 0;
 312             var order1 = rows[v1].order || 0;
 313             var order2 = rows[v2].order || 0;
 314
 315             if (g1 - g2 !== 0) {
 316                 return g1 - g2;
 317             }
 318
 319             if (order1 - order2 !== 0) {
 320                 return order1 - order2;
 321             }
 322
 323             if (v1 > v2) {
 324                 return 1;
 325             } else if (v1 < v2) {
 326                 return -1;
 327             } else {
 328                 return 0;
 329             }
 330         };
 331
 332         let baseurl = `nodes/${nodename}/qemu/${vmid}/config`;
 333
 334         let sm = Ext.create('Ext.selection.RowModel', {});
 335
 336         let run_editor = function() {
 337             let rec = sm.getSelection()[0];
 338             if (!rec || !rows[rec.data.key]?.editor) {
 339                 return;
 340             }
 341             let rowdef = rows[rec.data.key];
 342             let editor = rowdef.editor;
 343
 344             if (rowdef.isOnStorageBus) {
 345                 let value = me.getObjectValue(rec.data.key, '', true);
 346                 if (isCloudInitKey(value)) {
 347                     return;
 348                 } else if (value.match(/media=cdrom/)) {
 349                     editor = 'PVE.qemu.CDEdit';
 350                 } else if (!diskCap) {
 351                     return;
 352                 }
 353             }
 354
 355             let commonOpts = {
 356                 autoShow: true,
 357                 pveSelNode: me.pveSelNode,
 358                 confid: rec.data.key,
 359                 url: `/api2/extjs/${baseurl}`,
 360                 listeners: {
 361                     destroy: () => me.reload(),
 362                 },
 363             };
 364
 365             if (Ext.isString(editor)) {
 366                 Ext.create(editor, commonOpts);
 367             } else {
 368                 let win = Ext.createWidget(rowdef.editor.xtype, Ext.apply(commonOpts, rowdef.editor));
 369                 win.load();
 370             }
 371         };
 372
 373         let edit_btn = new Proxmox.button.Button({
 374             text: gettext('Edit'),
 375             selModel: sm,
 376             disabled: true,
 377             handler: run_editor,
 378         });
 379
 380         let move_menuitem = new Ext.menu.Item({
 381             text: gettext('Move Storage'),
 382             tooltip: gettext('Move disk to another storage'),
 383             iconCls: 'fa fa-database',
 384             selModel: sm,
 385             handler: () => {
 386                 let rec = sm.getSelection()[0];
 387                 if (!rec) {
 388                     return;
 389                 }
 390                 Ext.create('PVE.window.HDMove', {
 391                     autoShow: true,
 392                     disk: rec.data.key,
 393                     nodename: nodename,
 394                     vmid: vmid,
 395                     type: 'qemu',
 396                     listeners: {
 397                         destroy: () => me.reload(),
 398                     },
 399                 });
 400             },
 401         });
 402
 403         let reassign_menuitem = new Ext.menu.Item({
 404             text: gettext('Reassign Owner'),
 405             tooltip: gettext('Reassign disk to another VM'),
 406             iconCls: 'fa fa-desktop',
 407             selModel: sm,
 408             handler: () => {
 409                 let rec = sm.getSelection()[0];
 410                 if (!rec) {
 411                     return;
 412                 }
 413
 414                 Ext.create('PVE.window.GuestDiskReassign', {
 415                     autoShow: true,
 416                     disk: rec.data.key,
 417                     nodename: nodename,
 418                     vmid: vmid,
 419                     type: 'qemu',
 420                     listeners: {
 421                         destroy: () => me.reload(),
 422                     },
 423                 });
 424             },
 425         });
 426
 427         let resize_menuitem = new Ext.menu.Item({
 428             text: gettext('Resize'),
 429             iconCls: 'fa fa-plus',
 430             selModel: sm,
 431             handler: () => {
 432                 let rec = sm.getSelection()[0];
 433                 if (!rec) {
 434                     return;
 435                 }
 436                 Ext.create('PVE.window.HDResize', {
 437                     autoShow: true,
 438                     disk: rec.data.key,
 439                     nodename: nodename,
 440                     vmid: vmid,
 441                     listeners: {
 442                         destroy: () => me.reload(),
 443                     },
 444                 });
 445             },
 446         });
 447
 448         let diskaction_btn = new Proxmox.button.Button({
 449             text: gettext('Disk Action'),
 450             disabled: true,
 451             menu: {
 452                 items: [
 453                     move_menuitem,
 454                     reassign_menuitem,
 455                     resize_menuitem,
 456                 ],
 457             },
 458         });
 459
 460
 461         let remove_btn = new Proxmox.button.Button({
 462             text: gettext('Remove'),
 463             defaultText: gettext('Remove'),
 464             altText: gettext('Detach'),
 465             selModel: sm,
 466             disabled: true,
 467             dangerous: true,
 468             RESTMethod: 'PUT',
 469             confirmMsg: function(rec) {
 470                 let warn = gettext('Are you sure you want to remove entry {0}');
 471                 if (this.text === this.altText) {
 472                     warn = gettext('Are you sure you want to detach entry {0}');
 473                 }
 474                 let rendered = me.renderKey(rec.data.key, {}, rec);
 475                 let msg = Ext.String.format(warn, `'${rendered}'`);
 476
 477                 if (rows[rec.data.key].del_extra_msg) {
 478                     msg += '<br>' + rows[rec.data.key].del_extra_msg;
 479                 }
 480                 return msg;
 481             },
 482             handler: function(btn, e, rec) {
 483                 Proxmox.Utils.API2Request({
 484                     url: '/api2/extjs/' + baseurl,
 485                     waitMsgTarget: me,
 486                     method: btn.RESTMethod,
 487                     params: {
 488                         'delete': rec.data.key,
 489                     },
 490                     callback: () => me.reload(),
 491                     failure: response => Ext.Msg.alert('Error', response.htmlStatus),
 492                     success: function(response, options) {
 493                         if (btn.RESTMethod === 'POST') {
 494                             Ext.create('Proxmox.window.TaskProgress', {
 495                                 autoShow: true,
 496                                 upid: response.result.data,
 497                                 listeners: {
 498                                     destroy: () => me.reload(),
 499                                 },
 500                             });
 501                         }
 502                     },
 503                 });
 504             },
 505             listeners: {
 506                 render: function(btn) {
 507                     // hack: calculate the max button width on first display to prevent the whole
 508                     // toolbar to move when we switch between the "Remove" and "Detach" labels
 509                     var def = btn.getSize().width;
 510
 511                     btn.setText(btn.altText);
 512                     var alt = btn.getSize().width;
 513
 514                     btn.setText(btn.defaultText);
 515
 516                     var optimal = alt > def ? alt : def;
 517                     btn.setSize({ width: optimal });
 518                 },
 519             },
 520         });
 521
 522         let revert_btn = new PVE.button.PendingRevert({
 523             apiurl: '/api2/extjs/' + baseurl,
 524         });
 525
 526         let efidisk_menuitem = Ext.create('Ext.menu.Item', {
 527             text: gettext('EFI Disk'),
 528             iconCls: 'fa fa-fw fa-hdd-o black',
 529             disabled: !caps.vms['VM.Config.Disk'],
 530             handler: function() {
 531                 let { data: bios } = me.rstore.getData().map.bios || {};
 532
 533                 Ext.create('PVE.qemu.EFIDiskEdit', {
 534                     autoShow: true,
 535                     url: '/api2/extjs/' + baseurl,
 536                     pveSelNode: me.pveSelNode,
 537                     usesEFI: bios?.value === 'ovmf' || bios?.pending === 'ovmf',
 538                     listeners: {
 539                         destroy: () => me.reload(),
 540                     },
 541                 });
 542             },
 543         });
 544
 545         let counts = {};
 546         let isAtLimit = (type) => counts[type] >= PVE.Utils.hardware_counts[type];
 547
 548         let set_button_status = function() {
 549             let selection_model = me.getSelectionModel();
 550             let rec = selection_model.getSelection()[0];
 551
 552             counts = {}; // en/disable hardwarebuttons
 553             let hasCloudInit = false;
 554             me.rstore.getData().items.forEach(function({ id, data }) {
 555                 if (!hasCloudInit && (isCloudInitKey(data.value) || isCloudInitKey(data.pending))) {
 556                     hasCloudInit = true;
 557                     return;
 558                 }
 559
 560                 let match = id.match(/^([^\d]+)\d+$/);
 561                 if (match && PVE.Utils.hardware_counts[match[1]] !== undefined) {
 562                     let type = match[1];
 563                     counts[type] = (counts[type] || 0) + 1;
 564                 }
 565             });
 566
 567             // heuristic only for disabling some stuff, the backend has the final word.
 568             const noSysConsolePerm = !caps.nodes['Sys.Console'];
 569             const noVMConfigHWTypePerm = !caps.vms['VM.Config.HWType'];
 570             const noVMConfigNetPerm = !caps.vms['VM.Config.Network'];
 571             const noVMConfigDiskPerm = !caps.vms['VM.Config.Disk'];
 572
 573             me.down('#addUsb').setDisabled(noSysConsolePerm || isAtLimit('usb'));
 574             me.down('#addPci').setDisabled(noSysConsolePerm || isAtLimit('hostpci'));
 575             me.down('#addAudio').setDisabled(noVMConfigHWTypePerm || isAtLimit('audio'));
 576             me.down('#addSerial').setDisabled(noVMConfigHWTypePerm || isAtLimit('serial'));
 577             me.down('#addNet').setDisabled(noVMConfigNetPerm || isAtLimit('net'));
 578             me.down('#addRng').setDisabled(noSysConsolePerm || isAtLimit('rng'));
 579             efidisk_menuitem.setDisabled(noVMConfigDiskPerm || isAtLimit('efidisk'));
 580             me.down('#addTpmState').setDisabled(noSysConsolePerm || isAtLimit('tpmstate'));
 581             me.down('#addCloudinitDrive').setDisabled(noSysConsolePerm || hasCloudInit);
 582
 583             if (!rec) {
 584                 remove_btn.disable();
 585                 edit_btn.disable();
 586                 diskaction_btn.disable();
 587                 revert_btn.disable();
 588                 return;
 589             }
 590             const { key, value } = rec.data;
 591             const row = rows[key];
 592
 593             const deleted = !!rec.data.delete;
 594             const pending = deleted || me.hasPendingChanges(key);
 595
 596             const isCloudInit = isCloudInitKey(value);
 597             const isCDRom = value && !!value.toString().match(/media=cdrom/) && !isCloudInit;
 598
 599             const isUnusedDisk = key.match(/^unused\d+/);
 600             const isUsedDisk = !isUnusedDisk && row.isOnStorageBus && !isCDRom && !isCloudInit;
 601             const isDisk = isCloudInit || isUnusedDisk || isUsedDisk;
 602             const isEfi = key === 'efidisk0';
 603             const tpmMoveable = key === 'tpmstate0' && !me.pveSelNode.data.running;
 604
 605             remove_btn.setDisabled(
 606                 deleted || row.never_delete || (isCDRom && !cdromCap) || (isDisk && !diskCap));
 607             remove_btn.setText(isUsedDisk && !isCloudInit ? remove_btn.altText : remove_btn.defaultText);
 608             remove_btn.RESTMethod = isUnusedDisk ? 'POST':'PUT';
 609
 610             edit_btn.setDisabled(
 611                 deleted || !row.editor || isCloudInit || (isCDRom && !cdromCap) || (isDisk && !diskCap));
 612
 613             diskaction_btn.setDisabled(
 614                 pending ||
 615                 !diskCap ||
 616                 isCloudInit ||
 617                 !(isDisk || isEfi || tpmMoveable),
 618             );
 619             move_menuitem.setDisabled(isUnusedDisk);
 620             reassign_menuitem.setDisabled(pending || (isEfi || tpmMoveable));
 621             resize_menuitem.setDisabled(pending || !isUsedDisk);
 622
 623             revert_btn.setDisabled(!pending);
 624         };
 625
 626         let editorFactory = (classPath, extraOptions) => {
 627             extraOptions = extraOptions || {};
 628             return () => Ext.create(`PVE.qemu.${classPath}`, {
 629                 autoShow: true,
 630                 url: `/api2/extjs/${baseurl}`,
 631                 pveSelNode: me.pveSelNode,
 632                 listeners: {
 633                     destroy: () => me.reload(),
 634                 },
 635                 isAdd: true,
 636                 isCreate: true,
 637                 ...extraOptions,
 638             });
 639         };
 640
 641         Ext.apply(me, {
 642             url: `/api2/json/nodes/${nodename}/qemu/${vmid}/pending`,
 643             interval: 5000,
 644             selModel: sm,
 645             run_editor: run_editor,
 646             tbar: [
 647                 {
 648                     text: gettext('Add'),
 649                     menu: new Ext.menu.Menu({
 650                         cls: 'pve-add-hw-menu',
 651                         items: [
 652                             {
 653                                 text: gettext('Hard Disk'),
 654                                 iconCls: 'fa fa-fw fa-hdd-o black',
 655                                 disabled: !caps.vms['VM.Config.Disk'],
 656                                 handler: editorFactory('HDEdit'),
 657                             },
 658                             {
 659                                 text: gettext('CD/DVD Drive'),
 660                                 iconCls: 'pve-itype-icon-cdrom',
 661                                 disabled: !caps.vms['VM.Config.CDROM'],
 662                                 handler: editorFactory('CDEdit'),
 663                             },
 664                             {
 665                                 text: gettext('Network Device'),
 666                                 itemId: 'addNet',
 667                                 iconCls: 'fa fa-fw fa-exchange black',
 668                                 disabled: !caps.vms['VM.Config.Network'],
 669                                 handler: editorFactory('NetworkEdit'),
 670                             },
 671                             efidisk_menuitem,
 672                             {
 673                                 text: gettext('TPM State'),
 674                                 itemId: 'addTpmState',
 675                                 iconCls: 'fa fa-fw fa-hdd-o black',
 676                                 disabled: !caps.vms['VM.Config.Disk'],
 677                                 handler: editorFactory('TPMDiskEdit'),
 678                             },
 679                             {
 680                                 text: gettext('USB Device'),
 681                                 itemId: 'addUsb',
 682                                 iconCls: 'fa fa-fw fa-usb black',
 683                                 disabled: !caps.nodes['Sys.Console'],
 684                                 handler: editorFactory('USBEdit'),
 685                             },
 686                             {
 687                                 text: gettext('PCI Device'),
 688                                 itemId: 'addPci',
 689                                 iconCls: 'pve-itype-icon-pci',
 690                                 disabled: !caps.nodes['Sys.Console'],
 691                                 handler: editorFactory('PCIEdit'),
 692                             },
 693                             {
 694                                 text: gettext('Serial Port'),
 695                                 itemId: 'addSerial',
 696                                 iconCls: 'pve-itype-icon-serial',
 697                                 disabled: !caps.vms['VM.Config.Options'],
 698                                 handler: editorFactory('SerialEdit'),
 699                             },
 700                             {
 701                                 text: gettext('CloudInit Drive'),
 702                                 itemId: 'addCloudinitDrive',
 703                                 iconCls: 'fa fa-fw fa-cloud black',
 704                                 disabled: !caps.nodes['Sys.Console'],
 705                                 handler: editorFactory('CIDriveEdit'),
 706                             },
 707                             {
 708                                 text: gettext('Audio Device'),
 709                                 itemId: 'addAudio',
 710                                 iconCls: 'fa fa-fw fa-volume-up black',
 711                                 disabled: !caps.vms['VM.Config.HWType'],
 712                                 handler: editorFactory('AudioEdit'),
 713                             },
 714                             {
 715                                 text: gettext("VirtIO RNG"),
 716                                 itemId: 'addRng',
 717                                 iconCls: 'pve-itype-icon-die',
 718                                 disabled: !caps.nodes['Sys.Console'],
 719                                 handler: editorFactory('RNGEdit'),
 720                             },
 721                         ],
 722                     }),
 723                 },
 724                 remove_btn,
 725                 edit_btn,
 726                 diskaction_btn,
 727                 revert_btn,
 728             ],
 729             rows: rows,
 730             sorterFn: sorterFn,
 731             listeners: {
 732                 itemdblclick: run_editor,
 733                 selectionchange: set_button_status,
 734             },
 735         });
 736
 737         me.callParent();
 738
 739         me.on('activate', me.rstore.startUpdate, me.rstore);
 740         me.on('destroy', me.rstore.stopUpdate, me.rstore);
 741
 742         me.mon(me.getStore(), 'datachanged', set_button_status, me);
 743     },
 744 });