www/manager/qemu/Options.js

   1 /*jslint confusion: true */
   2 Ext.define('PVE.qemu.Options', {
   3     extend: 'PVE.grid.ObjectGrid',
   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: '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) {
  78                     var i;
  79                     var text = '';
  80                     var bootdisk = me.getObjectValue('bootdisk');
  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: '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: '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             acpi: {
 125                 header: 'ACPI support',
 126                 defaultValue: true,
 127                 renderer: PVE.Utils.format_boolean,
 128                 editor: caps.vms['VM.Config.HWType'] ? {
 129                     xtype: 'pveWindowEdit',
 130                     subject: 'ACPI support',
 131                     items: {
 132                         xtype: 'pvecheckbox',
 133                         name: 'acpi',
 134                         checked: true,
 135                         uncheckedValue: 0,
 136                         defaultValue: 1,
 137                         deleteDefaultValue: true,
 138                         fieldLabel: gettext('Enabled')
 139                     }
 140                 } : undefined
 141             },
 142             scsihw: {
 143                 header: 'SCSI Controller Type',
 144                 editor: caps.vms['VM.Config.Options'] ? 'PVE.qemu.ScsiHwEdit' : undefined,
 145                 renderer: PVE.Utils.render_scsihw,
 146                 defaultValue: ''
 147             },
 148             kvm: {
 149                 header: 'KVM hardware virtualization',
 150                 defaultValue: true,
 151                 renderer: PVE.Utils.format_boolean,
 152                 editor: caps.vms['VM.Config.HWType'] ? {
 153                     xtype: 'pveWindowEdit',
 154                     subject: 'KVM hardware virtualization',
 155                     items: {
 156                         xtype: 'pvecheckbox',
 157                         name: 'kvm',
 158                         checked: true,
 159                         uncheckedValue: 0,
 160                         defaultValue: 1,
 161                         deleteDefaultValue: true,
 162                         fieldLabel: gettext('Enabled')
 163                     }
 164                 } : undefined
 165             },
 166             cpuunits: {
 167                 header: 'CPU units',
 168                 defaultValue: '1000',
 169                 editor: caps.vms['VM.Config.CPU'] ? {
 170                     xtype: 'pveWindowEdit',
 171                     subject: 'CPU units',
 172                     items: {
 173                         xtype: 'numberfield',
 174                         name: 'cpuunits',
 175                         fieldLabel: 'CPU units',
 176                         minValue: 8,
 177                         maxValue: 500000,
 178                         defaultValue: 1000,
 179                         allowBlank: false
 180                     }
 181                 } : undefined
 182             },
 183             freeze: {
 184                 header: 'Freeze CPU at startup',
 185                 defaultValue: false,
 186                 renderer: PVE.Utils.format_boolean,
 187                 editor: caps.vms['VM.PowerMgmt'] ? {
 188                     xtype: 'pveWindowEdit',
 189                     subject: '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: 'Freeze CPU at startup'
 198                     }
 199                 } : undefined
 200             },
 201             localtime: {
 202                 header: '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: '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: 'Use local time for RTC'
 216                     }
 217                 } : undefined
 218             },
 219             startdate: {
 220                 header: 'RTC start date',
 221                 defaultValue: 'now',
 222                 editor: caps.vms['VM.Config.Options'] ? {
 223                     xtype: 'pveWindowEdit',
 224                     subject: 'RTC start date',
 225                     items: {
 226                         xtype: 'pvetextfield',
 227                         name: 'startdate',
 228                         deleteEmpty: true,
 229                         value: 'now',
 230                         fieldLabel: 'RTC start date',
 231                         vtype: 'QemuStartDate',
 232                         allowBlank: true
 233                     }
 234                 } : undefined
 235             }
 236         };
 237
 238         var baseurl = 'nodes/' + nodename + '/qemu/' + vmid + '/config';
 239
 240         var reload = function() {
 241             me.rstore.load();
 242         };
 243
 244         var run_editor = function() {
 245             var sm = me.getSelectionModel();
 246             var rec = sm.getSelection()[0];
 247             if (!rec) {
 248                 return;
 249             }
 250
 251             var rowdef = rows[rec.data.key];
 252             if (!rowdef.editor) {
 253                 return;
 254             }
 255
 256             var win;
 257             if (Ext.isString(rowdef.editor)) {
 258                 win = Ext.create(rowdef.editor, {
 259                     pveSelNode: me.pveSelNode,
 260                     confid: rec.data.key,
 261                     url: '/api2/extjs/' + baseurl
 262                 });
 263             } else {
 264                 var config = Ext.apply({
 265                     pveSelNode: me.pveSelNode,
 266                     confid: rec.data.key,
 267                     url: '/api2/extjs/' + baseurl
 268                 }, rowdef.editor);
 269                 win = Ext.createWidget(rowdef.editor.xtype, config);
 270                 win.load();
 271             }
 272
 273             win.show();
 274             win.on('destroy', reload);
 275         };
 276
 277         var edit_btn = new Ext.Button({
 278             text: gettext('Edit'),
 279             disabled: true,
 280             handler: run_editor
 281         });
 282
 283         var set_button_status = function() {
 284             var sm = me.getSelectionModel();
 285             var rec = sm.getSelection()[0];
 286
 287             if (!rec) {
 288                 edit_btn.disable();
 289                 return;
 290             }
 291             var rowdef = rows[rec.data.key];
 292             edit_btn.setDisabled(!rowdef.editor);
 293         };
 294
 295         Ext.applyIf(me, {
 296             url: "/api2/json/nodes/" + nodename + "/qemu/" + vmid + "/config",
 297             cwidth1: 150,
 298             tbar: [ edit_btn ],
 299             rows: rows,
 300             listeners: {
 301                 itemdblclick: run_editor,
 302                 selectionchange: set_button_status
 303             }
 304         });
 305
 306         me.callParent();
 307
 308         me.on('show', reload);
 309     }
 310 });
 311