www/manager6/qemu/HDEdit.js

   1 /*jslint confusion: true */
   2 /* 'change' property is assigned a string and then a function */
   3 Ext.define('PVE.qemu.HDInputPanel', {
   4     extend: 'Proxmox.panel.InputPanel',
   5     alias: 'widget.pveQemuHDInputPanel',
   6     onlineHelp: 'qm_hard_disk',
   7
   8     insideWizard: false,
   9
  10     unused: false, // ADD usused disk imaged
  11
  12     vmconfig: {}, // used to select usused disks
  13
  14     controller: {
  15
  16         xclass: 'Ext.app.ViewController',
  17
  18         onControllerChange: function(field) {
  19             var value = field.getValue();
  20
  21             var allowIOthread = value.match(/^(virtio|scsi)/);
  22             this.lookup('iothread').setDisabled(!allowIOthread);
  23             if (!allowIOthread) {
  24                 this.lookup('iothread').setValue(false);
  25             }
  26
  27             var scsi = value.match(/^scsi/);
  28             this.lookup('discard').setDisabled(!scsi);
  29             if (!scsi) {
  30                 this.lookup('discard').setValue(false);
  31             }
  32             this.lookup('scsiController').setVisible(scsi);
  33         },
  34
  35         control: {
  36             'field[name=controller]': {
  37                 change: 'onControllerChange',
  38                 afterrender: 'onControllerChange'
  39             },
  40             'field[name=iothread]' : {
  41                 change: function(f, value) {
  42                     if (!this.getView().insideWizard) {
  43                         return;
  44                     }
  45                     var vmScsiType = value ? 'virtio-scsi-single': 'virtio-scsi-pci';
  46                     this.lookupReference('scsiController').setValue(vmScsiType);
  47                 }
  48             }
  49         }
  50     },
  51
  52     onGetValues: function(values) {
  53         var me = this;
  54
  55         var params = {};
  56         var confid = me.confid || (values.controller + values.deviceid);
  57
  58         if (me.unused) {
  59             me.drive.file = me.vmconfig[values.unusedId];
  60             confid = values.controller + values.deviceid;
  61         } else if (me.isCreate) {
  62             if (values.hdimage) {
  63                 me.drive.file = values.hdimage;
  64             } else {
  65                 me.drive.file = values.hdstorage + ":" + values.disksize;
  66             }
  67             me.drive.format = values.diskformat;
  68         }
  69
  70         if (values.nobackup) {
  71             me.drive.backup = 'no';
  72         } else {
  73             delete me.drive.backup;
  74         }
  75
  76         if (values.noreplicate) {
  77             me.drive.replicate = 'no';
  78         } else {
  79             delete me.drive.replicate;
  80         }
  81
  82         if (values.discard) {
  83             me.drive.discard = 'on';
  84         } else {
  85             delete me.drive.discard;
  86         }
  87
  88         if (values.iothread) {
  89             me.drive.iothread = 'on';
  90         } else {
  91             delete me.drive.iothread;
  92         }
  93
  94         if (values.cache) {
  95             me.drive.cache = values.cache;
  96         } else {
  97             delete me.drive.cache;
  98         }
  99
 100         if (values.scsihw) {
 101             params.scsihw = values.scsihw;
 102         }
 103
 104         params[confid] = PVE.Parser.printQemuDrive(me.drive);
 105
 106         return params;
 107     },
 108
 109     setVMConfig: function(vmconfig) {
 110         var me = this;
 111
 112         me.vmconfig = vmconfig;
 113
 114         if (me.bussel) {
 115             me.bussel.setVMConfig(vmconfig);
 116             me.scsiController.setValue(vmconfig.scsihw);
 117         }
 118         if (me.unusedDisks) {
 119             var disklist = [];
 120             Ext.Object.each(vmconfig, function(key, value) {
 121                 if (key.match(/^unused\d+$/)) {
 122                     disklist.push([key, value]);
 123                 }
 124             });
 125             me.unusedDisks.store.loadData(disklist);
 126             me.unusedDisks.setValue(me.confid);
 127         }
 128     },
 129
 130     setDrive: function(drive) {
 131         var me = this;
 132
 133         me.drive = drive;
 134
 135         var values = {};
 136         var match = drive.file.match(/^([^:]+):/);
 137         if (match) {
 138             values.hdstorage = match[1];
 139         }
 140
 141         values.hdimage = drive.file;
 142         values.nobackup = !PVE.Parser.parseBoolean(drive.backup, 1);
 143         values.noreplicate = !PVE.Parser.parseBoolean(drive.replicate, 1);
 144         values.diskformat = drive.format || 'raw';
 145         values.cache = drive.cache || '__default__';
 146         values.discard = (drive.discard === 'on');
 147         values.iothread = PVE.Parser.parseBoolean(drive.iothread);
 148
 149         me.setValues(values);
 150     },
 151
 152     setNodename: function(nodename) {
 153         var me = this;
 154         me.down('#hdstorage').setNodename(nodename);
 155         me.down('#hdimage').setStorage(undefined, nodename);
 156     },
 157
 158     initComponent : function() {
 159         var me = this;
 160
 161         me.drive = {};
 162
 163         me.column1 = [];
 164         me.column2 = [];
 165
 166         me.advancedColumn1 = [];
 167         me.advancedColumn2 = [];
 168
 169         if (!me.confid || me.unused) {
 170             me.bussel = Ext.create('PVE.form.ControllerSelector', {
 171                 vmconfig: me.insideWizard ? {ide2: 'cdrom'} : {}
 172             });
 173             me.column1.push(me.bussel);
 174
 175             me.scsiController = Ext.create('Ext.form.field.Display', {
 176                 name: 'scsihw',
 177                 fieldLabel: gettext('SCSI Controller'),
 178                 reference: 'scsiController',
 179                 renderer: PVE.Utils.render_scsihw,
 180                 // do not change a VM wide option after creation
 181                 submitValue: me.insideWizard,
 182                 hidden: true
 183             });
 184             me.column1.push(me.scsiController);
 185         }
 186
 187         if (me.unused) {
 188             me.unusedDisks = Ext.create('Proxmox.form.KVComboBox', {
 189                 name: 'unusedId',
 190                 fieldLabel: gettext('Disk image'),
 191                 matchFieldWidth: false,
 192                 listConfig: {
 193                     width: 350
 194                 },
 195                 data: [],
 196                 allowBlank: false
 197             });
 198             me.column1.push(me.unusedDisks);
 199         } else if (me.isCreate) {
 200             me.column1.push({
 201                 xtype: 'pveDiskStorageSelector',
 202                 storageContent: 'images',
 203                 name: 'disk',
 204                 nodename: me.nodename,
 205                 autoSelect: me.insideWizard
 206             });
 207         } else {
 208             me.column1.push({
 209                 xtype: 'textfield',
 210                 disabled: true,
 211                 submitValue: false,
 212                 fieldLabel: gettext('Disk image'),
 213                 name: 'hdimage'
 214             });
 215         }
 216
 217         me.column2.push({
 218             xtype: 'CacheTypeSelector',
 219             name: 'cache',
 220             value: '__default__',
 221             fieldLabel: gettext('Cache')
 222         });
 223
 224         me.advancedColumn1.push(
 225             {
 226                 xtype: 'proxmoxcheckbox',
 227                 fieldLabel: gettext('Discard'),
 228                 disabled: me.confid && !me.confid.match(/^scsi/),
 229                 reference: 'discard',
 230                 labelWidth: labelWidth,
 231                 name: 'discard'
 232             },
 233             {
 234                 xtype: 'proxmoxcheckbox',
 235                 disabled: me.confid && !me.confid.match(/^(virtio|scsi)/),
 236                 fieldLabel: 'IO thread',
 237                 labelWidth: labelWidth,
 238                 reference: 'iothread',
 239                 name: 'iothread'
 240             }
 241         );
 242
 243         me.advancedColumn2.push(
 244             {
 245                 xtype: 'proxmoxcheckbox',
 246                 fieldLabel: gettext('No backup'),
 247                 labelWidth: labelWidth,
 248                 name: 'nobackup'
 249             },
 250             {
 251                 xtype: 'proxmoxcheckbox',
 252                 fieldLabel: gettext('Skip replication'),
 253                 labelWidth: labelWidth,
 254                 name: 'noreplicate'
 255             }
 256         );
 257
 258         me.callParent();
 259     }
 260 });
 261 /*jslint confusion: false */
 262
 263 Ext.define('PVE.qemu.HDEdit', {
 264     extend: 'Proxmox.window.Edit',
 265
 266     isAdd: true,
 267
 268     initComponent : function() {
 269         var me = this;
 270
 271         var nodename = me.pveSelNode.data.node;
 272         if (!nodename) {
 273             throw "no node name specified";
 274         }
 275
 276         var unused = me.confid && me.confid.match(/^unused\d+$/);
 277
 278         me.isCreate = me.confid ? unused : true;
 279
 280         var ipanel = Ext.create('PVE.qemu.HDInputPanel', {
 281             confid: me.confid,
 282             nodename: nodename,
 283             unused: unused,
 284             isCreate: me.isCreate
 285         });
 286
 287         var subject;
 288         if (unused) {
 289             me.subject = gettext('Unused Disk');
 290         } else if (me.isCreate) {
 291             me.subject = gettext('Hard Disk');
 292         } else {
 293            me.subject = gettext('Hard Disk') + ' (' + me.confid + ')';
 294         }
 295
 296         me.items = [ ipanel ];
 297
 298         me.callParent();
 299         /*jslint confusion: true*/
 300         /* 'data' is assigned an empty array in same file, and here we
 301          * use it like an object
 302          */
 303         me.load({
 304             success: function(response, options) {
 305                 ipanel.setVMConfig(response.result.data);
 306                 if (me.confid) {
 307                     var value = response.result.data[me.confid];
 308                     var drive = PVE.Parser.parseQemuDrive(me.confid, value);
 309                     if (!drive) {
 310                         Ext.Msg.alert(gettext('Error'), 'Unable to parse drive options');
 311                         me.close();
 312                         return;
 313                     }
 314                     ipanel.setDrive(drive);
 315                     me.isValid(); // trigger validation
 316                 }
 317             }
 318         });
 319         /*jslint confusion: false*/
 320     }
 321 });