www/manager6/qemu/Options.js

   1 Ext.define('PVE.qemu.Options', {
   2     extend: 'Proxmox.grid.PendingObjectGrid',
   3     alias: ['widget.PVE.qemu.Options'],
   4
   5     onlineHelp: 'qm_options',
   6
   7     initComponent: function() {
   8         var me = this;
   9
  10         var nodename = me.pveSelNode.data.node;
  11         if (!nodename) {
  12             throw "no node name specified";
  13         }
  14
  15         var vmid = me.pveSelNode.data.vmid;
  16         if (!vmid) {
  17             throw "no VM ID specified";
  18         }
  19
  20         var caps = Ext.state.Manager.get('GuiCap');
  21
  22         var rows = {
  23             name: {
  24                 required: true,
  25                 defaultValue: me.pveSelNode.data.name,
  26                 header: gettext('Name'),
  27                 editor: caps.vms['VM.Config.Options'] ? {
  28                     xtype: 'proxmoxWindowEdit',
  29                     subject: gettext('Name'),
  30                     items: {
  31                         xtype: 'inputpanel',
  32                         items: {
  33                             xtype: 'textfield',
  34                             name: 'name',
  35                             vtype: 'DnsName',
  36                             value: '',
  37                             fieldLabel: gettext('Name'),
  38                             allowBlank: true,
  39                         },
  40                         onGetValues: function(values) {
  41                             var params = values;
  42                             if (values.name === undefined ||
  43                                 values.name === null ||
  44                                 values.name === '') {
  45                                 params = { 'delete': 'name' };
  46                             }
  47                             return params;
  48                         },
  49                     },
  50                 } : undefined,
  51             },
  52             onboot: {
  53                 header: gettext('Start at boot'),
  54                 defaultValue: '',
  55                 renderer: Proxmox.Utils.format_boolean,
  56                 editor: caps.vms['VM.Config.Options'] ? {
  57                     xtype: 'proxmoxWindowEdit',
  58                     subject: gettext('Start at boot'),
  59                     items: {
  60                         xtype: 'proxmoxcheckbox',
  61                         name: 'onboot',
  62                         uncheckedValue: 0,
  63                         defaultValue: 0,
  64                         deleteDefaultValue: true,
  65                         fieldLabel: gettext('Start at boot'),
  66                     },
  67                 } : undefined,
  68             },
  69             startup: {
  70                 header: gettext('Start/Shutdown order'),
  71                 defaultValue: '',
  72                 renderer: PVE.Utils.render_kvm_startup,
  73                 editor: caps.vms['VM.Config.Options'] && caps.nodes['Sys.Modify']
  74                     ? {
  75                         xtype: 'pveWindowStartupEdit',
  76                         onlineHelp: 'qm_startup_and_shutdown',
  77                     } : undefined,
  78             },
  79             ostype: {
  80                 header: gettext('OS Type'),
  81                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.OSTypeEdit' : undefined,
  82                 renderer: PVE.Utils.render_kvm_ostype,
  83                 defaultValue: 'other',
  84             },
  85             bootdisk: {
  86                 visible: false,
  87             },
  88             boot: {
  89                 header: gettext('Boot Order'),
  90                 defaultValue: 'cdn',
  91                 editor: caps.vms['VM.Config.Disk'] ? 'PVE.qemu.BootOrderEdit' : undefined,
  92                 multiKey: ['boot', 'bootdisk'],
  93                 renderer: function(order, metaData, record, rowIndex, colIndex, store, pending) {
  94                     if (/^\s*$/.test(order)) {
  95                         return gettext('(No boot device selected)');
  96                     }
  97                     let boot = PVE.Parser.parsePropertyString(order, "legacy");
  98                     if (boot.order) {
  99                         let list = boot.order.split(';');
 100                         let ret = '';
 101                         list.forEach(dev => {
 102                             if (ret) {
 103                                 ret += ', ';
 104                             }
 105                             ret += dev;
 106                         });
 107                         return ret;
 108                     }
 109
 110                     // legacy style and fallback
 111                     let i;
 112                     var text = '';
 113                     var bootdisk = me.getObjectValue('bootdisk', undefined, pending);
 114                     order = boot.legacy || 'cdn';
 115                     for (i = 0; i < order.length; i++) {
 116                         if (text) {
 117                             text += ', ';
 118                         }
 119                         var sel = order.substring(i, i + 1);
 120                         if (sel === 'c') {
 121                             if (bootdisk) {
 122                                 text += bootdisk;
 123                             } else {
 124                                 text += gettext('(no bootdisk)');
 125                             }
 126                         } else if (sel === 'n') {
 127                             text += gettext('any net');
 128                         } else if (sel === 'a') {
 129                             text += gettext('Floppy');
 130                         } else if (sel === 'd') {
 131                             text += gettext('any CD-ROM');
 132                         } else {
 133                             text += sel;
 134                         }
 135                     }
 136                     return text;
 137                 },
 138             },
 139             tablet: {
 140                 header: gettext('Use tablet for pointer'),
 141                 defaultValue: true,
 142                 renderer: Proxmox.Utils.format_boolean,
 143                 editor: caps.vms['VM.Config.HWType'] ? {
 144                     xtype: 'proxmoxWindowEdit',
 145                     subject: gettext('Use tablet for pointer'),
 146                     items: {
 147                         xtype: 'proxmoxcheckbox',
 148                         name: 'tablet',
 149                         checked: true,
 150                         uncheckedValue: 0,
 151                         defaultValue: 1,
 152                         deleteDefaultValue: true,
 153                         fieldLabel: gettext('Enabled'),
 154                     },
 155                 } : undefined,
 156             },
 157             hotplug: {
 158                 header: gettext('Hotplug'),
 159                 defaultValue: 'disk,network,usb',
 160                 renderer: PVE.Utils.render_hotplug_features,
 161                 editor: caps.vms['VM.Config.HWType'] ? {
 162                     xtype: 'proxmoxWindowEdit',
 163                     subject: gettext('Hotplug'),
 164                     items: {
 165                         xtype: 'pveHotplugFeatureSelector',
 166                         name: 'hotplug',
 167                         value: '',
 168                         multiSelect: true,
 169                         fieldLabel: gettext('Hotplug'),
 170                         allowBlank: true,
 171                     },
 172                 } : undefined,
 173             },
 174             acpi: {
 175                 header: gettext('ACPI support'),
 176                 defaultValue: true,
 177                 renderer: Proxmox.Utils.format_boolean,
 178                 editor: caps.vms['VM.Config.HWType'] ? {
 179                     xtype: 'proxmoxWindowEdit',
 180                     subject: gettext('ACPI support'),
 181                     items: {
 182                         xtype: 'proxmoxcheckbox',
 183                         name: 'acpi',
 184                         checked: true,
 185                         uncheckedValue: 0,
 186                         defaultValue: 1,
 187                         deleteDefaultValue: true,
 188                         fieldLabel: gettext('Enabled'),
 189                     },
 190                 } : undefined,
 191             },
 192             kvm: {
 193                 header: gettext('KVM hardware virtualization'),
 194                 defaultValue: true,
 195                 renderer: Proxmox.Utils.format_boolean,
 196                 editor: caps.vms['VM.Config.HWType'] ? {
 197                     xtype: 'proxmoxWindowEdit',
 198                     subject: gettext('KVM hardware virtualization'),
 199                     items: {
 200                         xtype: 'proxmoxcheckbox',
 201                         name: 'kvm',
 202                         checked: true,
 203                         uncheckedValue: 0,
 204                         defaultValue: 1,
 205                         deleteDefaultValue: true,
 206                         fieldLabel: gettext('Enabled'),
 207                     },
 208                 } : undefined,
 209             },
 210             freeze: {
 211                 header: gettext('Freeze CPU at startup'),
 212                 defaultValue: false,
 213                 renderer: Proxmox.Utils.format_boolean,
 214                 editor: caps.vms['VM.PowerMgmt'] ? {
 215                     xtype: 'proxmoxWindowEdit',
 216                     subject: gettext('Freeze CPU at startup'),
 217                     items: {
 218                         xtype: 'proxmoxcheckbox',
 219                         name: 'freeze',
 220                         uncheckedValue: 0,
 221                         defaultValue: 0,
 222                         deleteDefaultValue: true,
 223                         labelWidth: 140,
 224                         fieldLabel: gettext('Freeze CPU at startup'),
 225                     },
 226                 } : undefined,
 227             },
 228             localtime: {
 229                 header: gettext('Use local time for RTC'),
 230                 defaultValue: '__default__',
 231                 renderer: PVE.Utils.render_localtime,
 232                 editor: caps.vms['VM.Config.Options'] ? {
 233                     xtype: 'proxmoxWindowEdit',
 234                     subject: gettext('Use local time for RTC'),
 235                     width: 400,
 236                     items: {
 237                         xtype: 'proxmoxKVComboBox',
 238                         name: 'localtime',
 239                         value: '__default__',
 240                         comboItems: [
 241                             ['__default__', PVE.Utils.render_localtime('__default__')],
 242                             [1, PVE.Utils.render_localtime(1)],
 243                             [0, PVE.Utils.render_localtime(0)],
 244                         ],
 245                         labelWidth: 140,
 246                         fieldLabel: gettext('Use local time for RTC'),
 247                     },
 248                 } : undefined,
 249             },
 250             startdate: {
 251                 header: gettext('RTC start date'),
 252                 defaultValue: 'now',
 253                 editor: caps.vms['VM.Config.Options'] ? {
 254                     xtype: 'proxmoxWindowEdit',
 255                     subject: gettext('RTC start date'),
 256                     items: {
 257                         xtype: 'proxmoxtextfield',
 258                         name: 'startdate',
 259                         deleteEmpty: true,
 260                         value: 'now',
 261                         fieldLabel: gettext('RTC start date'),
 262                         vtype: 'QemuStartDate',
 263                         allowBlank: true,
 264                     },
 265                 } : undefined,
 266             },
 267             smbios1: {
 268                 header: gettext('SMBIOS settings (type1)'),
 269                 defaultValue: '',
 270                 renderer: Ext.String.htmlEncode,
 271                 editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.Smbios1Edit' : undefined,
 272             },
 273             agent: {
 274                 header: 'QEMU Guest Agent',
 275                 defaultValue: false,
 276                 renderer: PVE.Utils.render_qga_features,
 277                 editor: caps.vms['VM.Config.Options'] ? {
 278                     xtype: 'proxmoxWindowEdit',
 279                     subject: gettext('Qemu Agent'),
 280                     width: 350,
 281                     items: {
 282                         xtype: 'pveAgentFeatureSelector',
 283                         name: 'agent',
 284                     },
 285                 } : undefined,
 286             },
 287             protection: {
 288                 header: gettext('Protection'),
 289                 defaultValue: false,
 290                 renderer: Proxmox.Utils.format_boolean,
 291                 editor: caps.vms['VM.Config.Options'] ? {
 292                     xtype: 'proxmoxWindowEdit',
 293                     subject: gettext('Protection'),
 294                     items: {
 295                         xtype: 'proxmoxcheckbox',
 296                         name: 'protection',
 297                         uncheckedValue: 0,
 298                         defaultValue: 0,
 299                         deleteDefaultValue: true,
 300                         fieldLabel: gettext('Enabled'),
 301                     },
 302                 } : undefined,
 303             },
 304             spice_enhancements: {
 305                 header: gettext('Spice Enhancements'),
 306                 defaultValue: false,
 307                 renderer: PVE.Utils.render_spice_enhancements,
 308                 editor: caps.vms['VM.Config.Options'] ? {
 309                     xtype: 'proxmoxWindowEdit',
 310                     subject: gettext('Spice Enhancements'),
 311                     onlineHelp: 'qm_spice_enhancements',
 312                     items: {
 313                         xtype: 'pveSpiceEnhancementSelector',
 314                         name: 'spice_enhancements',
 315                     },
 316                 } : undefined,
 317             },
 318             vmstatestorage: {
 319                 header: gettext('VM State storage'),
 320                 defaultValue: '',
 321                 renderer: val => val || gettext('Automatic'),
 322                 editor: caps.vms['VM.Config.Options'] ? {
 323                     xtype: 'proxmoxWindowEdit',
 324                     subject: gettext('VM State storage'),
 325                     onlineHelp: 'chapter_virtual_machines', // FIXME: use 'qm_vmstatestorage' once available
 326                     width: 350,
 327                     items: {
 328                         xtype: 'pveStorageSelector',
 329                         storageContent: 'images',
 330                         allowBlank: true,
 331                         emptyText: gettext("Automatic (Storage used by the VM, or 'local')"),
 332                         autoSelect: false,
 333                         deleteEmpty: true,
 334                         skipEmptyText: true,
 335                         nodename: nodename,
 336                         name: 'vmstatestorage',
 337                     },
 338                 } : undefined,
 339             },
 340             hookscript: {
 341                 header: gettext('Hookscript'),
 342             },
 343         };
 344
 345         var baseurl = 'nodes/' + nodename + '/qemu/' + vmid + '/config';
 346
 347         var edit_btn = new Ext.Button({
 348             text: gettext('Edit'),
 349             disabled: true,
 350             handler: function() { me.run_editor(); },
 351         });
 352
 353         var revert_btn = new PVE.button.PendingRevert();
 354
 355         var set_button_status = function() {
 356             var sm = me.getSelectionModel();
 357             var rec = sm.getSelection()[0];
 358
 359             if (!rec) {
 360                 edit_btn.disable();
 361                 return;
 362             }
 363
 364             var key = rec.data.key;
 365             var pending = rec.data.delete || me.hasPendingChanges(key);
 366             var rowdef = rows[key];
 367
 368             edit_btn.setDisabled(!rowdef.editor);
 369             revert_btn.setDisabled(!pending);
 370         };
 371
 372         Ext.apply(me, {
 373             url: "/api2/json/nodes/" + nodename + "/qemu/" + vmid + "/pending",
 374             interval: 5000,
 375             cwidth1: 250,
 376             tbar: [edit_btn, revert_btn],
 377             rows: rows,
 378             editorConfig: {
 379                 url: "/api2/extjs/" + baseurl,
 380             },
 381             listeners: {
 382                 itemdblclick: me.run_editor,
 383                 selectionchange: set_button_status,
 384             },
 385         });
 386
 387         me.callParent();
 388
 389         me.on('activate', () => me.rstore.startUpdate());
 390         me.on('destroy', () => me.rstore.stopUpdate());
 391         me.on('deactivate', () => me.rstore.stopUpdate());
 392
 393         me.mon(me.getStore(), 'datachanged', function() {
 394             set_button_status();
 395         });
 396     },
 397 });
 398