www/manager6/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 || '__default__';
  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                         if (!value) { // initial store loading fires an unwanted 'change'
 173                             return;
 174                         }
 175                         var rec = f.store.getById(value);
 176                         if (rec.data.type === 'iscsi') {
 177                             me.hdfilesel.setStorage(value);
 178                             me.hdfilesel.setDisabled(false);
 179                             me.formatsel.setValue('raw');
 180                             me.formatsel.setDisabled(true);
 181                             me.hdfilesel.setVisible(true);
 182                             me.hdsizesel.setDisabled(true);
 183                             me.hdsizesel.setVisible(false);
 184                         } else if (rec.data.type === 'lvm' ||
 185                                    rec.data.type === 'lvmthin' ||
 186                                    rec.data.type === 'rbd' ||
 187                                    rec.data.type === 'sheepdog' ||
 188                                    rec.data.type === 'zfs' ||
 189                                    rec.data.type === 'zfspool') {
 190                             me.hdfilesel.setDisabled(true);
 191                             me.hdfilesel.setVisible(false);
 192                             me.formatsel.setValue('raw');
 193                             me.formatsel.setDisabled(true);
 194                             me.hdsizesel.setDisabled(false);
 195                             me.hdsizesel.setVisible(true);
 196                         } else {
 197                             me.hdfilesel.setDisabled(true);
 198                             me.hdfilesel.setVisible(false);
 199                             me.formatsel.setValue('qcow2');
 200                             me.formatsel.setDisabled(false);
 201                             me.hdsizesel.setDisabled(false);
 202                             me.hdsizesel.setVisible(true);
 203                         }
 204                     }
 205                 }
 206             });
 207             me.column1.push(me.hdstoragesel);
 208             me.column1.push(me.hdfilesel);
 209             me.column1.push(me.hdsizesel);
 210             me.column1.push(me.formatsel);
 211
 212         } else {
 213             me.column1.push({
 214                 xtype: 'textfield',
 215                 disabled: true,
 216                 submitValue: false,
 217                 fieldLabel: gettext('Disk image'),
 218                 name: 'hdimage'
 219             });
 220         }
 221
 222         me.column2.push({
 223             xtype: 'CacheTypeSelector',
 224             name: 'cache',
 225             value: '__default__',
 226             fieldLabel: gettext('Cache')
 227         });
 228
 229         me.column2.push({
 230             xtype: 'pvecheckbox',
 231             fieldLabel: gettext('No backup'),
 232             name: 'nobackup'
 233         });
 234
 235         me.column2.push({
 236             xtype: 'pvecheckbox',
 237             fieldLabel: gettext('Discard'),
 238             name: 'discard'
 239         });
 240
 241         me.column2.push({
 242             xtype: 'pvecheckbox',
 243             fieldLabel: gettext('IO thread'),
 244             name: 'iothread'
 245         });
 246
 247         me.callParent();
 248     }
 249 });
 250
 251 Ext.define('PVE.qemu.HDEdit', {
 252     extend: 'PVE.window.Edit',
 253
 254     isAdd: true,
 255
 256     initComponent : function() {
 257         var me = this;
 258
 259         var nodename = me.pveSelNode.data.node;
 260         if (!nodename) {
 261             throw "no node name specified";
 262         }
 263
 264         var unused = me.confid && me.confid.match(/^unused\d+$/);
 265
 266         me.create = me.confid ? unused : true;
 267
 268         var ipanel = Ext.create('PVE.qemu.HDInputPanel', {
 269             confid: me.confid,
 270             nodename: nodename,
 271             unused: unused,
 272             create: me.create
 273         });
 274
 275         var subject;
 276         if (unused) {
 277             me.subject = gettext('Unused Disk');
 278         } else if (me.create) {
 279             me.subject = gettext('Hard Disk');
 280         } else {
 281            me.subject = gettext('Hard Disk') + ' (' + me.confid + ')';
 282         }
 283
 284         me.items = [ ipanel ];
 285
 286         me.callParent();
 287
 288         me.load({
 289             success: function(response, options) {
 290                 ipanel.setVMConfig(response.result.data);
 291                 if (me.confid) {
 292                     var value = response.result.data[me.confid];
 293                     var drive = PVE.Parser.parseQemuDrive(me.confid, value);
 294                     if (!drive) {
 295                         Ext.Msg.alert(gettext('Error'), 'Unable to parse drive options');
 296                         me.close();
 297                         return;
 298                     }
 299                     ipanel.setDrive(drive);
 300                     me.isValid(); // trigger validation
 301                 }
 302             }
 303         });
 304     }
 305 });