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