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