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