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.cache) {
  31             me.drive.cache = values.cache;
  32         } else {
  33             delete me.drive.cache;
  34         }
  35
  36         if (values.nobackup) {
  37             me.drive.backup = 'no';
  38         } else {
  39             delete me.drive.backup;
  40         }
  41
  42         var params = {};
  43
  44         params[confid] = PVE.Parser.printQemuDrive(me.drive);
  45
  46         return params;
  47     },
  48
  49     setVMConfig: function(vmconfig) {
  50         var me = this;
  51
  52         me.vmconfig = vmconfig;
  53
  54         if (me.bussel) {
  55             me.bussel.setVMConfig(vmconfig, true);
  56         }
  57         if (me.unusedDisks) {
  58             var disklist = [];
  59             Ext.Object.each(vmconfig, function(key, value) {
  60                 if (key.match(/^unused\d+$/)) {
  61                     disklist.push([key, value]);
  62                 }
  63             });
  64             me.unusedDisks.store.loadData(disklist);
  65             me.unusedDisks.setValue(me.confid);
  66         }
  67     },
  68
  69     setDrive: function(drive) {
  70         var me = this;
  71
  72         me.drive = drive;
  73
  74         var values = {};
  75         var match = drive.file.match(/^([^:]+):/);
  76         if (match) {
  77             values.hdstorage = match[1];
  78         }
  79
  80         values.hdimage = drive.file;
  81         values.nobackup = (drive.backup === 'no');
  82         values.diskformat = drive.format || 'raw';
  83         values.cache = drive.cache || '';
  84
  85         me.setValues(values);
  86     },
  87
  88     setNodename: function(nodename) {
  89         var me = this;
  90         me.hdstoragesel.setNodename(nodename);
  91         me.hdfilesel.setStorage(undefined, nodename);
  92     },
  93
  94     initComponent : function() {
  95         var me = this;
  96
  97         me.drive = {};
  98
  99         me.column1 = [];
 100         me.column2 = [];
 101
 102         if (!me.confid || me.unused) {
 103             me.bussel = Ext.createWidget('PVE.form.ControllerSelector', {
 104                 // boot from scsi does not work in kvm 1.0
 105                 noScsi: me.insideWizard ? true : false,
 106                 vmconfig: me.insideWizard ? {ide2: 'cdrom'} : {}
 107             });
 108             me.column1.push(me.bussel);
 109         }
 110
 111         if (me.unused) {
 112             me.unusedDisks = Ext.create('PVE.form.KVComboBox', {
 113                 name: 'unusedId',
 114                 fieldLabel: gettext('Disk image'),
 115                 matchFieldWidth: false,
 116                 listConfig: {
 117                     width: 350
 118                 },
 119                 data: [],
 120                 allowBlank: false
 121             });
 122             me.column1.push(me.unusedDisks);
 123         } else if (me.create) {
 124             me.hdfilesel = Ext.create('PVE.form.FileSelector', {
 125                 name: 'hdimage',
 126                 nodename: me.nodename,
 127                 storageContent: 'images',
 128                 fieldLabel: gettext('Disk image'),
 129                 disabled: true,
 130                 hidden: true,
 131                 allowBlank: false
 132             });
 133
 134             me.hdsizesel = Ext.createWidget('numberfield', {
 135                 name: 'disksize',
 136                 minValue: 1,
 137                 maxValue: 128*1024,
 138                 value: '32',
 139                 fieldLabel: gettext('Disk size') + ' (GB)',
 140                 allowBlank: false
 141             });
 142
 143             me.hdstoragesel = Ext.create('PVE.form.StorageSelector', {
 144                 name: 'hdstorage',
 145                 nodename: me.nodename,
 146                 fieldLabel: gettext('Storage'),
 147                 storageContent: 'images',
 148                 autoSelect: me.insideWizard,
 149                 allowBlank: false,
 150                 listeners: {
 151                     change: function(f, value) {
 152                         var rec = f.store.getById(value);
 153                         if (rec.data.type === 'iscsi') {
 154                             me.hdfilesel.setStorage(value);
 155                             me.hdfilesel.setDisabled(false);
 156                             me.hdfilesel.setVisible(true);
 157                             me.hdsizesel.setDisabled(true);
 158                             me.hdsizesel.setVisible(false);
 159                         } else {
 160                             me.hdfilesel.setDisabled(true);
 161                             me.hdfilesel.setVisible(false);
 162                             me.hdsizesel.setDisabled(false);
 163                             me.hdsizesel.setVisible(true);
 164                         }
 165                     }
 166                 }
 167             });
 168             me.column1.push(me.hdstoragesel);
 169             me.column1.push(me.hdfilesel);
 170             me.column1.push(me.hdsizesel);
 171         } else {
 172             me.column1.push({
 173                 xtype: 'displayfield',
 174                 fieldLabel: gettext('Disk image'),
 175                 labelWidth: 50,
 176                 name: 'hdimage'
 177             });
 178         }
 179
 180         if (me.create && !me.unused) {
 181             me.column2.push({
 182                 xtype: 'PVE.form.DiskFormatSelector',
 183                 name: 'diskformat',
 184                 fieldLabel: gettext('Format'),
 185                 value: 'raw',
 186                 allowBlank: false
 187             });
 188         }
 189
 190         me.column2.push({
 191             xtype: 'CacheTypeSelector',
 192             name: 'cache',
 193             value: '',
 194             fieldLabel: 'Cache'
 195         });
 196
 197         if (!me.insideWizard) {
 198             me.column2.push({
 199                 xtype: 'pvecheckbox',
 200                 fieldLabel: gettext('No backup'),
 201                 name: 'nobackup'
 202             });
 203         }
 204
 205         me.callParent();
 206     }
 207 });
 208
 209 Ext.define('PVE.qemu.HDEdit', {
 210     extend: 'PVE.window.Edit',
 211
 212     isAdd: true,
 213
 214     initComponent : function() {
 215         var me = this;
 216
 217         var nodename = me.pveSelNode.data.node;
 218         if (!nodename) {
 219             throw "no node name specified";
 220         }
 221
 222         var unused = me.confid && me.confid.match(/^unused\d+$/);
 223
 224         me.create = me.confid ? unused : true;
 225
 226         var ipanel = Ext.create('PVE.qemu.HDInputPanel', {
 227             confid: me.confid,
 228             nodename: nodename,
 229             unused: unused,
 230             create: me.create
 231         });
 232
 233         var subject;
 234         if (unused) {
 235             me.subject = gettext('Unused Disk');
 236         } else if (me.create) {
 237             me.subject = gettext('Hard Disk');
 238         } else {
 239            me.subject = gettext('Hard Disk') + ' (' + me.confid + ')';
 240         }
 241
 242         me.items = [ ipanel ];
 243
 244         me.callParent();
 245
 246         me.load({
 247             success: function(response, options) {
 248                 ipanel.setVMConfig(response.result.data);
 249                 if (me.confid) {
 250                     var value = response.result.data[me.confid];
 251                     var drive = PVE.Parser.parseQemuDrive(me.confid, value);
 252                     if (!drive) {
 253                         Ext.Msg.alert('Error', 'Unable to parse drive options');
 254                         me.close();
 255                         return;
 256                     }
 257                     ipanel.setDrive(drive);
 258                     me.isValid(); // trigger validation
 259                 }
 260             }
 261         });
 262     }
 263 });