www/manager/qemu/HDEdit.js

   1 // fixme: howto avoid jslint type confusion?
   2 /*jslint confusion: true */
   3 Ext.define('PVE.qemu.HDInputPanel', {
   4     extend: 'PVE.panel.InputPanel',
   5     alias: 'widget.PVE.qemu.HDInputPanel',
   6
   7     insideWizard: false,
   8
   9     unused: false, // ADD usused disk imaged
  10
  11     vmconfig: {}, // used to select usused disks
  12
  13     onGetValues: function(values) {
  14         var me = this;
  15
  16         var confid = me.confid || (values.controller + values.deviceid);
  17
  18         if (me.unused) {
  19             me.drive.file = me.vmconfig[values.unusedId];
  20             confid = values.controller + values.deviceid;
  21         } else if (me.create) {
  22             if (values.hdimage) {
  23                 me.drive.file = values.hdimage;
  24             } else {
  25                 me.drive.file = values.hdstorage + ":" + values.disksize;
  26             }
  27             me.drive.format = values.diskformat;
  28         }
  29
  30         if (values.nobackup) {
  31             me.drive.backup = 'no';
  32         } else {
  33             delete me.drive.backup;
  34         }
  35
  36         if (values.discard) {
  37             me.drive.discard = 'on';
  38         } else {
  39             delete me.drive.discard;
  40         }
  41
  42         if (values.iothread && confid.match(/^virtio\d+$/)) {
  43             me.drive.iothread = 'on';
  44         } else {
  45             delete me.drive.iothread;
  46         }
  47
  48         if (values.cache) {
  49             me.drive.cache = values.cache;
  50         } else {
  51             delete me.drive.cache;
  52         }
  53
  54         var params = {};
  55
  56         params[confid] = PVE.Parser.printQemuDrive(me.drive);
  57
  58         return params;
  59     },
  60
  61     setVMConfig: function(vmconfig) {
  62         var me = this;
  63
  64         me.vmconfig = vmconfig;
  65
  66         if (me.bussel) {
  67             me.bussel.setVMConfig(vmconfig, true);
  68         }
  69         if (me.unusedDisks) {
  70             var disklist = [];
  71             Ext.Object.each(vmconfig, function(key, value) {
  72                 if (key.match(/^unused\d+$/)) {
  73                     disklist.push([key, value]);
  74                 }
  75             });
  76             me.unusedDisks.store.loadData(disklist);
  77             me.unusedDisks.setValue(me.confid);
  78         }
  79     },
  80
  81     setDrive: function(drive) {
  82         var me = this;
  83
  84         me.drive = drive;
  85
  86         var values = {};
  87         var match = drive.file.match(/^([^:]+):/);
  88         if (match) {
  89             values.hdstorage = match[1];
  90         }
  91
  92         values.hdimage = drive.file;
  93         values.nobackup = !PVE.Parser.parseBoolean(drive.backup, 1);
  94         values.diskformat = drive.format || 'raw';
  95         values.cache = drive.cache || '';
  96         values.discard = (drive.discard === 'on');
  97         values.iothread = PVE.Parser.parseBoolean(drive.iothread);
  98
  99         me.setValues(values);
 100     },
 101
 102     setNodename: function(nodename) {
 103         var me = this;
 104         me.hdstoragesel.setNodename(nodename);
 105         me.hdfilesel.setStorage(undefined, nodename);
 106     },
 107
 108     initComponent : function() {
 109         var me = this;
 110
 111         me.drive = {};
 112
 113         me.column1 = [];
 114         me.column2 = [];
 115
 116         if (!me.confid || me.unused) {
 117             me.bussel = Ext.createWidget('PVE.form.ControllerSelector', {
 118                 vmconfig: me.insideWizard ? {ide2: 'cdrom'} : {}
 119             });
 120             me.column1.push(me.bussel);
 121         }
 122
 123         if (me.unused) {
 124             me.unusedDisks = Ext.create('PVE.form.KVComboBox', {
 125                 name: 'unusedId',
 126                 fieldLabel: gettext('Disk image'),
 127                 matchFieldWidth: false,
 128                 listConfig: {
 129                     width: 350
 130                 },
 131                 data: [],
 132                 allowBlank: false
 133             });
 134             me.column1.push(me.unusedDisks);
 135         } else if (me.create) {
 136             me.formatsel = Ext.create('PVE.form.DiskFormatSelector', {
 137                 name: 'diskformat',
 138                 fieldLabel: gettext('Format'),
 139                 value: 'qcow2',
 140                 allowBlank: false
 141             });
 142
 143             me.hdfilesel = Ext.create('PVE.form.FileSelector', {
 144                 name: 'hdimage',
 145                 nodename: me.nodename,
 146                 storageContent: 'images',
 147                 fieldLabel: gettext('Disk image'),
 148                 disabled: true,
 149                 hidden: true,
 150                 allowBlank: false
 151             });
 152
 153             me.hdsizesel = Ext.createWidget('numberfield', {
 154                 name: 'disksize',
 155                 minValue: 0.001,
 156                 maxValue: 128*1024,
 157                 decimalPrecision: 3,
 158                 value: '32',
 159                 fieldLabel: gettext('Disk size') + ' (GB)',
 160                 allowBlank: false
 161             });
 162
 163             me.hdstoragesel = Ext.create('PVE.form.StorageSelector', {
 164                 name: 'hdstorage',
 165                 nodename: me.nodename,
 166                 fieldLabel: gettext('Storage'),
 167                 storageContent: 'images',
 168                 autoSelect: me.insideWizard,
 169                 allowBlank: false,
 170                 listeners: {
 171                     change: function(f, value) {
 172                         var rec = f.store.getById(value);
 173                         if (rec.data.type === 'iscsi') {
 174                             me.hdfilesel.setStorage(value);
 175                             me.hdfilesel.setDisabled(false);
 176                             me.formatsel.setValue('raw');
 177                             me.formatsel.setDisabled(true);
 178                             me.hdfilesel.setVisible(true);
 179                             me.hdsizesel.setDisabled(true);
 180                             me.hdsizesel.setVisible(false);
 181                         } else if (rec.data.type === 'lvm' ||
 182                                    rec.data.type === 'lvmthin' ||
 183                                    rec.data.type === 'drbd' ||
 184                                    rec.data.type === 'rbd' ||
 185                                    rec.data.type === 'sheepdog' ||
 186                                    rec.data.type === 'zfs' ||
 187                                    rec.data.type === 'zfspool') {
 188                             me.hdfilesel.setDisabled(true);
 189                             me.hdfilesel.setVisible(false);
 190                             me.formatsel.setValue('raw');
 191                             me.formatsel.setDisabled(true);
 192                             me.hdsizesel.setDisabled(false);
 193                             me.hdsizesel.setVisible(true);
 194                         } else {
 195                             me.hdfilesel.setDisabled(true);
 196                             me.hdfilesel.setVisible(false);
 197                             me.formatsel.setValue('qcow2');
 198                             me.formatsel.setDisabled(false);
 199                             me.hdsizesel.setDisabled(false);
 200                             me.hdsizesel.setVisible(true);
 201                         }
 202                     }
 203                 }
 204             });
 205             me.column1.push(me.hdstoragesel);
 206             me.column1.push(me.hdfilesel);
 207             me.column1.push(me.hdsizesel);
 208             me.column1.push(me.formatsel);
 209
 210         } else {
 211             me.column1.push({
 212                 xtype: 'textfield',
 213                 disabled: true,
 214                 submitValue: false,
 215                 fieldLabel: gettext('Disk image'),
 216                 name: 'hdimage'
 217             });
 218         }
 219
 220         me.column2.push({
 221             xtype: 'CacheTypeSelector',
 222             name: 'cache',
 223             value: '',
 224             fieldLabel: gettext('Cache')
 225         });
 226
 227         me.column2.push({
 228             xtype: 'pvecheckbox',
 229             fieldLabel: gettext('No backup'),
 230             name: 'nobackup'
 231         });
 232
 233         me.column2.push({
 234             xtype: 'pvecheckbox',
 235             fieldLabel: gettext('Discard'),
 236             name: 'discard'
 237         });
 238
 239         me.column2.push({
 240             xtype: 'pvecheckbox',
 241             fieldLabel: gettext('Iothread'),
 242             name: 'iothread'
 243         });
 244
 245         me.callParent();
 246     }
 247 });
 248
 249 Ext.define('PVE.qemu.HDEdit', {
 250     extend: 'PVE.window.Edit',
 251
 252     isAdd: true,
 253
 254     initComponent : function() {
 255         var me = this;
 256
 257         var nodename = me.pveSelNode.data.node;
 258         if (!nodename) {
 259             throw "no node name specified";
 260         }
 261
 262         var unused = me.confid && me.confid.match(/^unused\d+$/);
 263
 264         me.create = me.confid ? unused : true;
 265
 266         var ipanel = Ext.create('PVE.qemu.HDInputPanel', {
 267             confid: me.confid,
 268             nodename: nodename,
 269             unused: unused,
 270             create: me.create
 271         });
 272
 273         var subject;
 274         if (unused) {
 275             me.subject = gettext('Unused Disk');
 276         } else if (me.create) {
 277             me.subject = gettext('Hard Disk');
 278         } else {
 279            me.subject = gettext('Hard Disk') + ' (' + me.confid + ')';
 280         }
 281
 282         me.items = [ ipanel ];
 283
 284         me.callParent();
 285
 286         me.load({
 287             success: function(response, options) {
 288                 ipanel.setVMConfig(response.result.data);
 289                 if (me.confid) {
 290                     var value = response.result.data[me.confid];
 291                     var drive = PVE.Parser.parseQemuDrive(me.confid, value);
 292                     if (!drive) {
 293                         Ext.Msg.alert(gettext('Error'), gettext('Unable to parse drive options'));
 294                         me.close();
 295                         return;
 296                     }
 297                     ipanel.setDrive(drive);
 298                     me.isValid(); // trigger validation
 299                 }
 300             }
 301         });
 302     }
 303 });