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: 'PVE.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         if (!me.confid || me.unused) {
 167             me.bussel = Ext.create('PVE.form.ControllerSelector', {
 168                 vmconfig: me.insideWizard ? {ide2: 'cdrom'} : {}
 169             });
 170             me.column1.push(me.bussel);
 171
 172             me.scsiController = Ext.create('Ext.form.field.Display', {
 173                 name: 'scsihw',
 174                 fieldLabel: gettext('SCSI Controller'),
 175                 reference: 'scsiController',
 176                 renderer: PVE.Utils.render_scsihw,
 177                 // do not change a VM wide option after creation
 178                 submitValue: me.insideWizard,
 179                 hidden: true
 180             });
 181             me.column1.push(me.scsiController);
 182         }
 183
 184         if (me.unused) {
 185             me.unusedDisks = Ext.create('PVE.form.KVComboBox', {
 186                 name: 'unusedId',
 187                 fieldLabel: gettext('Disk image'),
 188                 matchFieldWidth: false,
 189                 listConfig: {
 190                     width: 350
 191                 },
 192                 data: [],
 193                 allowBlank: false
 194             });
 195             me.column1.push(me.unusedDisks);
 196         } else if (me.isCreate) {
 197             me.column1.push({
 198                 xtype: 'pveDiskStorageSelector',
 199                 storageContent: 'images',
 200                 name: 'disk',
 201                 nodename: me.nodename,
 202                 autoSelect: me.insideWizard
 203             });
 204         } else {
 205             me.column1.push({
 206                 xtype: 'textfield',
 207                 disabled: true,
 208                 submitValue: false,
 209                 fieldLabel: gettext('Disk image'),
 210                 name: 'hdimage'
 211             });
 212         }
 213
 214         me.column2.push({
 215             xtype: 'CacheTypeSelector',
 216             name: 'cache',
 217             value: '__default__',
 218             fieldLabel: gettext('Cache')
 219         },
 220         {
 221             xtype: 'proxmoxcheckbox',
 222             fieldLabel: gettext('No backup'),
 223             name: 'nobackup'
 224         },
 225         {
 226             xtype: 'proxmoxcheckbox',
 227             hidden: me.insideWizard,
 228             fieldLabel: gettext('Skip replication'),
 229             name: 'noreplicate'
 230         },
 231         {
 232             xtype: 'proxmoxcheckbox',
 233             fieldLabel: gettext('Discard'),
 234             disabled: me.confid && !me.confid.match(/^scsi/),
 235             reference: 'discard',
 236             name: 'discard'
 237         },
 238         {
 239             xtype: 'proxmoxcheckbox',
 240             disabled: me.confid && !me.confid.match(/^(virtio|scsi)/),
 241             fieldLabel: 'IO thread',
 242             reference: 'iothread',
 243             name: 'iothread'
 244         });
 245
 246         me.callParent();
 247     }
 248 });
 249 /*jslint confusion: false */
 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.isCreate = me.confid ? unused : true;
 267
 268         var ipanel = Ext.create('PVE.qemu.HDInputPanel', {
 269             confid: me.confid,
 270             nodename: nodename,
 271             unused: unused,
 272             isCreate: me.isCreate
 273         });
 274
 275         var subject;
 276         if (unused) {
 277             me.subject = gettext('Unused Disk');
 278         } else if (me.isCreate) {
 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         /*jslint confusion: true*/
 288         /* 'data' is assigned an empty array in same file, and here we
 289          * use it like an object
 290          */
 291         me.load({
 292             success: function(response, options) {
 293                 ipanel.setVMConfig(response.result.data);
 294                 if (me.confid) {
 295                     var value = response.result.data[me.confid];
 296                     var drive = PVE.Parser.parseQemuDrive(me.confid, value);
 297                     if (!drive) {
 298                         Ext.Msg.alert(gettext('Error'), 'Unable to parse drive options');
 299                         me.close();
 300                         return;
 301                     }
 302                     ipanel.setDrive(drive);
 303                     me.isValid(); // trigger validation
 304                 }
 305             }
 306         });
 307         /*jslint confusion: false*/
 308     }
 309 });