www/manager/qemu/Options.js

   1 /*jslint confusion: true */
   2 Ext.define('PVE.qemu.Options', {
   3     extend: 'PVE.grid.PendingObjectGrid',
   4     alias: ['widget.PVE.qemu.Options'],
   5
   6     initComponent : function() {
   7         var me = this;
   8         var i;
   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: 'pveWindowEdit',
  29                     subject: gettext('Name'),
  30                     items: {
  31                         xtype: 'textfield',
  32                         name: 'name',
  33                         vtype: 'DnsName',
  34                         value: '',
  35                         fieldLabel: gettext('Name'),
  36                         allowBlank: true
  37                     }
  38                 } : undefined
  39             },
  40             onboot: {
  41                 header: gettext('Start at boot'),
  42                 defaultValue: '',
  43                 renderer: PVE.Utils.format_boolean,
  44                 editor: caps.vms['VM.Config.Options'] ? {
  45                     xtype: 'pveWindowEdit',
  46                     subject: gettext('Start at boot'),
  47                     items: {
  48                         xtype: 'pvecheckbox',
  49                         name: 'onboot',
  50                         uncheckedValue: 0,
  51                         defaultValue: 0,
  52                         deleteDefaultValue: true,
  53                         fieldLabel: gettext('Start at boot')
  54                     }
  55                 } : undefined
  56             },
  57             startup: {
  58                 header: gettext('Start/Shutdown order'),
  59                 defaultValue: '',
  60                 renderer: PVE.Utils.render_kvm_startup,
  61                 editor: caps.vms['VM.Config.Options'] && caps.nodes['Sys.Modify'] ?
  62                     'PVE.qemu.StartupEdit' : undefined
  63             },
  64             ostype: {
  65                 header: gettext('OS Type'),
  66                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.OSTypeEdit' : undefined,
  67                 renderer: PVE.Utils.render_kvm_ostype,
  68                 defaultValue: 'other'
  69             },
  70             bootdisk: {
  71                 visible: false
  72             },
  73             boot: {
  74                 header: gettext('Boot order'),
  75                 defaultValue: 'cdn',
  76                 editor: caps.vms['VM.Config.Disk'] ? 'PVE.qemu.BootOrderEdit' : undefined,
  77                 renderer: function(order, metaData, record, rowIndex, colIndex, store, pending) {
  78                     var i;
  79                     var text = '';
  80                     var bootdisk = me.getObjectValue('bootdisk', undefined, pending);
  81                     order = order || 'cdn';
  82                     for (i = 0; i < order.length; i++) {
  83                         var sel = order.substring(i, i + 1);
  84                         if (text) {
  85                             text += ', ';
  86                         }
  87                         if (sel === 'c') {
  88                             if (bootdisk) {
  89                                 text += "Disk '" + bootdisk + "'";
  90                             } else {
  91                                 text += "Disk";
  92                             }
  93                         } else if (sel === 'n') {
  94                             text += 'Network';
  95                         } else if (sel === 'a') {
  96                             text += 'Floppy';
  97                         } else if (sel === 'd') {
  98                             text += 'CD-ROM';
  99                         } else {
 100                             text += sel;
 101                         }
 102                     }
 103                     return text;
 104                 }
 105             },
 106             tablet: {
 107                 header: gettext('Use tablet for pointer'),
 108                 defaultValue: true,
 109                 renderer: PVE.Utils.format_boolean,
 110                 editor: caps.vms['VM.Config.HWType'] ? {
 111                     xtype: 'pveWindowEdit',
 112                     subject: gettext('Use tablet for pointer'),
 113                     items: {
 114                         xtype: 'pvecheckbox',
 115                         name: 'tablet',
 116                         checked: true,
 117                         uncheckedValue: 0,
 118                         defaultValue: 1,
 119                         deleteDefaultValue: true,
 120                         fieldLabel: gettext('Enabled')
 121                     }
 122                 } : undefined
 123             },
 124             hotplug: {
 125                 header: gettext('Hotplug'),
 126                 defaultValue: 'disk,network,usb',
 127                 renderer:  PVE.Utils.render_hotplug_features,
 128                 editor: caps.vms['VM.Config.HWType'] ? {
 129                     xtype: 'pveWindowEdit',
 130                     subject: gettext('Hotplug'),
 131                     items: {
 132                         xtype: 'pveHotplugFeatureSelector',
 133                         name: 'hotplug',
 134                         value: '',
 135                         multiSelect: true,
 136                         fieldLabel: gettext('Hotplug'),
 137                         allowBlank: true
 138                     }
 139                 } : undefined
 140             },
 141             acpi: {
 142                 header: gettext('ACPI support'),
 143                 defaultValue: true,
 144                 renderer: PVE.Utils.format_boolean,
 145                 editor: caps.vms['VM.Config.HWType'] ? {
 146                     xtype: 'pveWindowEdit',
 147                     subject: gettext('ACPI support'),
 148                     items: {
 149                         xtype: 'pvecheckbox',
 150                         name: 'acpi',
 151                         checked: true,
 152                         uncheckedValue: 0,
 153                         defaultValue: 1,
 154                         deleteDefaultValue: true,
 155                         fieldLabel: gettext('Enabled')
 156                     }
 157                 } : undefined
 158             },
 159             scsihw: {
 160                 header: gettext('SCSI Controller Type'),
 161                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.ScsiHwEdit' : undefined,
 162                 renderer: PVE.Utils.render_scsihw,
 163                 defaultValue: ''
 164             },
 165             bios: {
 166                 header: 'BIOS',
 167                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.BiosEdit' : undefined,
 168                 renderer: PVE.Utils.render_qemu_bios,
 169                 defaultValue: ''
 170             },
 171             kvm: {
 172                 header: gettext('KVM hardware virtualization'),
 173                 defaultValue: true,
 174                 renderer: PVE.Utils.format_boolean,
 175                 editor: caps.vms['VM.Config.HWType'] ? {
 176                     xtype: 'pveWindowEdit',
 177                     subject: gettext('KVM hardware virtualization'),
 178                     items: {
 179                         xtype: 'pvecheckbox',
 180                         name: 'kvm',
 181                         checked: true,
 182                         uncheckedValue: 0,
 183                         defaultValue: 1,
 184                         deleteDefaultValue: true,
 185                         fieldLabel: gettext('Enabled')
 186                     }
 187                 } : undefined
 188             },
 189             freeze: {
 190                 header: gettext('Freeze CPU at startup'),
 191                 defaultValue: false,
 192                 renderer: PVE.Utils.format_boolean,
 193                 editor: caps.vms['VM.PowerMgmt'] ? {
 194                     xtype: 'pveWindowEdit',
 195                     subject: gettext('Freeze CPU at startup'),
 196                     items: {
 197                         xtype: 'pvecheckbox',
 198                         name: 'freeze',
 199                         uncheckedValue: 0,
 200                         defaultValue: 0,
 201                         deleteDefaultValue: true,
 202                         labelWidth: 140,
 203                         fieldLabel: gettext('Freeze CPU at startup')
 204                     }
 205                 } : undefined
 206             },
 207             localtime: {
 208                 header: gettext('Use local time for RTC'),
 209                 defaultValue: false,
 210                 renderer: PVE.Utils.format_boolean,
 211                 editor: caps.vms['VM.Config.Options'] ? {
 212                     xtype: 'pveWindowEdit',
 213                     subject: gettext('Use local time for RTC'),
 214                     items: {
 215                         xtype: 'pvecheckbox',
 216                         name: 'localtime',
 217                         uncheckedValue: 0,
 218                         defaultValue: 0,
 219                         deleteDefaultValue: true,
 220                         labelWidth: 140,
 221                         fieldLabel: gettext('Use local time for RTC')
 222                     }
 223                 } : undefined
 224             },
 225             startdate: {
 226                 header: gettext('RTC start date'),
 227                 defaultValue: 'now',
 228                 editor: caps.vms['VM.Config.Options'] ? {
 229                     xtype: 'pveWindowEdit',
 230                     subject: gettext('RTC start date'),
 231                     items: {
 232                         xtype: 'pvetextfield',
 233                         name: 'startdate',
 234                         deleteEmpty: true,
 235                         value: 'now',
 236                         fieldLabel: gettext('RTC start date'),
 237                         vtype: 'QemuStartDate',
 238                         allowBlank: true
 239                     }
 240                 } : undefined
 241             },
 242             smbios1: {
 243                 header: gettext('SMBIOS settings (type1)'),
 244                 defaultValue: '',
 245                 editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.Smbios1Edit' : undefined
 246             },
 247             agent: {
 248                 header: gettext('Qemu Agent'),
 249                 defaultValue: false,
 250                 renderer: PVE.Utils.format_boolean,
 251                 editor: caps.vms['VM.Config.Options'] ? {
 252                     xtype: 'pveWindowEdit',
 253                     subject: gettext('Qemu Agent'),
 254                     items: {
 255                         xtype: 'pvecheckbox',
 256                         name: 'agent',
 257                         uncheckedValue: 0,
 258                         defaultValue: 0,
 259                         deleteDefaultValue: true,
 260                         fieldLabel: gettext('Enabled')
 261                     }
 262                 } : undefined
 263             },
 264             protection: {
 265                 header: gettext('VM protection'),
 266                 defaultValue: false,
 267                 renderer: PVE.Utils.format_boolean,
 268                 editor: caps.vms['VM.Config.Options'] ? {
 269                     xtype: 'pveWindowEdit',
 270                     subject: gettext('VM protection'),
 271                     items: {
 272                         xtype: 'pvecheckbox',
 273                         name: 'protection',
 274                         uncheckedValue: 0,
 275                         defaultValue: 0,
 276                         deleteDefaultValue: true,
 277                         fieldLabel: gettext('Enabled')
 278                     }
 279                 } : undefined
 280             }
 281         };
 282
 283         var baseurl = 'nodes/' + nodename + '/qemu/' + vmid + '/config';
 284
 285         var reload = function() {
 286             me.rstore.load();
 287         };
 288
 289         var run_editor = function() {
 290             var sm = me.getSelectionModel();
 291             var rec = sm.getSelection()[0];
 292             if (!rec) {
 293                 return;
 294             }
 295
 296             var rowdef = rows[rec.data.key];
 297             if (!rowdef.editor) {
 298                 return;
 299             }
 300
 301             var win;
 302             if (Ext.isString(rowdef.editor)) {
 303                 win = Ext.create(rowdef.editor, {
 304                     pveSelNode: me.pveSelNode,
 305                     confid: rec.data.key,
 306                     url: '/api2/extjs/' + baseurl
 307                 });
 308             } else {
 309                 var config = Ext.apply({
 310                     pveSelNode: me.pveSelNode,
 311                     confid: rec.data.key,
 312                     url: '/api2/extjs/' + baseurl
 313                 }, rowdef.editor);
 314                 win = Ext.createWidget(rowdef.editor.xtype, config);
 315                 win.load();
 316             }
 317
 318             win.show();
 319             win.on('destroy', reload);
 320         };
 321
 322         var edit_btn = new Ext.Button({
 323             text: gettext('Edit'),
 324             disabled: true,
 325             handler: run_editor
 326         });
 327
 328         var revert_btn = new PVE.button.Button({
 329             text: gettext('Revert'),
 330             disabled: true,
 331             handler: function() {
 332                 var sm = me.getSelectionModel();
 333                 var rec = sm.getSelection()[0];
 334                 if (!rec) {
 335                     return;
 336                 }
 337
 338                 PVE.Utils.API2Request({
 339                     url: '/api2/extjs/' + baseurl,
 340                     waitMsgTarget: me,
 341                     method: 'PUT',
 342                     params: {
 343                         'revert': rec.data.key
 344                     },
 345                     callback: function() {
 346                         reload();
 347                     },
 348                     failure: function (response, opts) {
 349                         Ext.Msg.alert('Error',response.htmlStatus);
 350                     }
 351                 });
 352             }
 353         });
 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.applyIf(me, {
 373             url: "/api2/json/nodes/" + nodename + "/qemu/" + vmid + "/pending",
 374             interval: 5000,
 375             cwidth1: 170,
 376             tbar: [ edit_btn, revert_btn ],
 377             rows: rows,
 378             listeners: {
 379                 itemdblclick: run_editor,
 380                 selectionchange: set_button_status
 381             }
 382         });
 383
 384         me.callParent();
 385
 386         me.on('show', me.rstore.startUpdate);
 387         me.on('hide', me.rstore.stopUpdate);
 388         me.on('destroy', me.rstore.stopUpdate);
 389
 390         me.rstore.on('datachanged', function() {
 391             set_button_status();
 392         });
 393     }
 394 });
 395