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