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             kvm: {
 166                 header: gettext('KVM hardware virtualization'),
 167                 defaultValue: true,
 168                 renderer: PVE.Utils.format_boolean,
 169                 editor: caps.vms['VM.Config.HWType'] ? {
 170                     xtype: 'pveWindowEdit',
 171                     subject: gettext('KVM hardware virtualization'),
 172                     items: {
 173                         xtype: 'pvecheckbox',
 174                         name: 'kvm',
 175                         checked: true,
 176                         uncheckedValue: 0,
 177                         defaultValue: 1,
 178                         deleteDefaultValue: true,
 179                         fieldLabel: gettext('Enabled')
 180                     }
 181                 } : undefined
 182             },
 183             freeze: {
 184                 header: gettext('Freeze CPU at startup'),
 185                 defaultValue: false,
 186                 renderer: PVE.Utils.format_boolean,
 187                 editor: caps.vms['VM.PowerMgmt'] ? {
 188                     xtype: 'pveWindowEdit',
 189                     subject: gettext('Freeze CPU at startup'),
 190                     items: {
 191                         xtype: 'pvecheckbox',
 192                         name: 'freeze',
 193                         uncheckedValue: 0,
 194                         defaultValue: 0,
 195                         deleteDefaultValue: true,
 196                         labelWidth: 140,
 197                         fieldLabel: gettext('Freeze CPU at startup')
 198                     }
 199                 } : undefined
 200             },
 201             localtime: {
 202                 header: gettext('Use local time for RTC'),
 203                 defaultValue: false,
 204                 renderer: PVE.Utils.format_boolean,
 205                 editor: caps.vms['VM.Config.Options'] ? {
 206                     xtype: 'pveWindowEdit',
 207                     subject: gettext('Use local time for RTC'),
 208                     items: {
 209                         xtype: 'pvecheckbox',
 210                         name: 'localtime',
 211                         uncheckedValue: 0,
 212                         defaultValue: 0,
 213                         deleteDefaultValue: true,
 214                         labelWidth: 140,
 215                         fieldLabel: gettext('Use local time for RTC')
 216                     }
 217                 } : undefined
 218             },
 219             startdate: {
 220                 header: gettext('RTC start date'),
 221                 defaultValue: 'now',
 222                 editor: caps.vms['VM.Config.Options'] ? {
 223                     xtype: 'pveWindowEdit',
 224                     subject: gettext('RTC start date'),
 225                     items: {
 226                         xtype: 'pvetextfield',
 227                         name: 'startdate',
 228                         deleteEmpty: true,
 229                         value: 'now',
 230                         fieldLabel: gettext('RTC start date'),
 231                         vtype: 'QemuStartDate',
 232                         allowBlank: true
 233                     }
 234                 } : undefined
 235             },
 236             smbios1: {
 237                 header: gettext('SMBIOS settings (type1)'),
 238                 defaultValue: '',
 239                 editor: caps.vms['VM.Config.HWType'] ? 'PVE.qemu.Smbios1Edit' : undefined
 240             },
 241             agent: {
 242                 header: gettext('Qemu Agent'),
 243                 defaultValue: false,
 244                 renderer: PVE.Utils.format_boolean,
 245                 editor: caps.vms['VM.Config.Options'] ? {
 246                     xtype: 'pveWindowEdit',
 247                     subject: gettext('Qemu Agent'),
 248                     items: {
 249                         xtype: 'pvecheckbox',
 250                         name: 'agent',
 251                         uncheckedValue: 0,
 252                         defaultValue: 0,
 253                         deleteDefaultValue: true,
 254                         fieldLabel: gettext('Enabled')
 255                     }
 256                 } : undefined
 257             },
 258             protection: {
 259                 header: gettext('VM protection'),
 260                 defaultValue: false,
 261                 renderer: PVE.Utils.format_boolean,
 262                 editor: caps.vms['VM.Config.Options'] ? {
 263                     xtype: 'pveWindowEdit',
 264                     subject: gettext('VM protection'),
 265                     items: {
 266                         xtype: 'pvecheckbox',
 267                         name: 'protection',
 268                         uncheckedValue: 0,
 269                         defaultValue: 0,
 270                         deleteDefaultValue: true,
 271                         fieldLabel: gettext('Enabled')
 272                     }
 273                 } : undefined
 274             }
 275         };
 276
 277         var baseurl = 'nodes/' + nodename + '/qemu/' + vmid + '/config';
 278
 279         var reload = function() {
 280             me.rstore.load();
 281         };
 282
 283         var run_editor = function() {
 284             var sm = me.getSelectionModel();
 285             var rec = sm.getSelection()[0];
 286             if (!rec) {
 287                 return;
 288             }
 289
 290             var rowdef = rows[rec.data.key];
 291             if (!rowdef.editor) {
 292                 return;
 293             }
 294
 295             var win;
 296             if (Ext.isString(rowdef.editor)) {
 297                 win = Ext.create(rowdef.editor, {
 298                     pveSelNode: me.pveSelNode,
 299                     confid: rec.data.key,
 300                     url: '/api2/extjs/' + baseurl
 301                 });
 302             } else {
 303                 var config = Ext.apply({
 304                     pveSelNode: me.pveSelNode,
 305                     confid: rec.data.key,
 306                     url: '/api2/extjs/' + baseurl
 307                 }, rowdef.editor);
 308                 win = Ext.createWidget(rowdef.editor.xtype, config);
 309                 win.load();
 310             }
 311
 312             win.show();
 313             win.on('destroy', reload);
 314         };
 315
 316         var edit_btn = new Ext.Button({
 317             text: gettext('Edit'),
 318             disabled: true,
 319             handler: run_editor
 320         });
 321
 322         var revert_btn = new PVE.button.Button({
 323             text: gettext('Revert'),
 324             disabled: true,
 325             handler: function() {
 326                 var sm = me.getSelectionModel();
 327                 var rec = sm.getSelection()[0];
 328                 if (!rec) {
 329                     return;
 330                 }
 331
 332                 PVE.Utils.API2Request({
 333                     url: '/api2/extjs/' + baseurl,
 334                     waitMsgTarget: me,
 335                     method: 'PUT',
 336                     params: {
 337                         'revert': rec.data.key
 338                     },
 339                     callback: function() {
 340                         reload();
 341                     },
 342                     failure: function (response, opts) {
 343                         Ext.Msg.alert('Error',response.htmlStatus);
 344                     }
 345                 });
 346             }
 347         });
 348
 349         var set_button_status = function() {
 350             var sm = me.getSelectionModel();
 351             var rec = sm.getSelection()[0];
 352
 353             if (!rec) {
 354                 edit_btn.disable();
 355                 return;
 356             }
 357
 358             var key = rec.data.key;
 359             var pending = rec.data['delete'] || me.hasPendingChanges(key);
 360             var rowdef = rows[key];
 361
 362             edit_btn.setDisabled(!rowdef.editor);
 363             revert_btn.setDisabled(!pending);
 364         };
 365
 366         Ext.applyIf(me, {
 367             url: "/api2/json/nodes/" + nodename + "/qemu/" + vmid + "/pending",
 368             interval: 5000,
 369             cwidth1: 170,
 370             tbar: [ edit_btn, revert_btn ],
 371             rows: rows,
 372             listeners: {
 373                 itemdblclick: run_editor,
 374                 selectionchange: set_button_status
 375             }
 376         });
 377
 378         me.callParent();
 379
 380         me.on('show', me.rstore.startUpdate);
 381         me.on('hide', me.rstore.stopUpdate);
 382         me.on('destroy', me.rstore.stopUpdate);
 383
 384         me.rstore.on('datachanged', function() {
 385             set_button_status();
 386         });
 387     }
 388 });
 389