www/manager6/lxc/MPEdit.js

   1 Ext.define('PVE.lxc.MountPointInputPanel', {
   2     extend: 'PVE.panel.InputPanel',
   3     alias: 'widget.pveLxcMountPointInputPanel',
   4
   5     insideWizard: false,
   6
   7     onlineHelp: 'pct_container_storage',
   8
   9     unused: false, // add unused disk imaged
  10
  11     unprivileged: false,
  12
  13     vmconfig: {}, // used to select unused disks
  14
  15     onGetValues: function(values) {
  16         var me = this;
  17
  18         var confid = me.confid || values.mpsel;
  19
  20         if (me.unused) {
  21             me.mpdata.file = me.vmconfig[values.unusedId];
  22             confid = values.mpsel;
  23         } else if (me.isCreate) {
  24             me.mpdata.file = values.hdstorage + ':' + values.disksize;
  25         }
  26
  27         if (confid !== 'rootfs') {
  28             me.mpdata.mp = values.mp;
  29         }
  30
  31         if (values.ro) {
  32             me.mpdata.ro = 1;
  33         } else {
  34             delete me.mpdata.ro;
  35         }
  36
  37         if (values.quota) {
  38             me.mpdata.quota = 1;
  39         } else {
  40             delete me.mpdata.quota;
  41         }
  42
  43         if (values.acl === 'Default') {
  44             delete me.mpdata.acl;
  45         } else {
  46             me.mpdata.acl = values.acl;
  47         }
  48
  49         if (values.backup) {
  50             me.mpdata.backup = 1;
  51         } else {
  52             delete me.mpdata.backup;
  53         }
  54
  55         if (values.noreplicate) {
  56             me.mpdata.replicate = '0';
  57         }
  58         delete me.mpdata.noreplicate;
  59
  60         var res = {};
  61         res[confid] = PVE.Parser.printLxcMountPoint(me.mpdata);
  62         return res;
  63     },
  64
  65     setMountPoint: function(mp) {
  66         var me = this;
  67
  68         // the fields name is 'hdstorage',
  69         // but the api expects/has 'storage'
  70         mp.hdstorage = mp.storage;
  71         delete mp.hdstorage;
  72
  73         me.mpdata = mp;
  74         if (!Ext.isDefined(me.mpdata.acl)) {
  75             me.mpdata.acl = 'Default';
  76         }
  77
  78         if (mp.type === 'bind') {
  79             me.quota.setDisabled(true);
  80             me.quota.setValue(false);
  81             me.acl.setDisabled(true);
  82             me.acl.setValue('Default');
  83             me.down('#hdstorage').setDisabled(true);
  84             if (me.confid !== 'rootfs') {
  85                 me.backup.setDisabled(true);
  86             }
  87         }
  88
  89         if (mp.replicate) { // check box reverses the config option
  90             mp.noreplicate = !PVE.Parser.parseBoolean(mp.replicate, 1);
  91             delete mp.replicate;
  92         }
  93
  94         me.setValues(mp);
  95     },
  96
  97     setVMConfig: function(vmconfig) {
  98         var me = this;
  99
 100         me.vmconfig = vmconfig;
 101
 102         if (me.mpsel) {
 103             var i;
 104             for (i = 0; i != 8; ++i) {
 105                 var name = "mp" + i.toString();
 106                 if (!Ext.isDefined(vmconfig[name])) {
 107                     me.mpsel.setValue(name);
 108                     break;
 109                 }
 110             }
 111         }
 112
 113         if (me.unusedDisks) {
 114             var disklist = [];
 115             Ext.Object.each(vmconfig, function(key, value) {
 116                 if (key.match(/^unused\d+$/)) {
 117                     disklist.push([key, value]);
 118                 }
 119             });
 120             me.unusedDisks.store.loadData(disklist);
 121             me.unusedDisks.setValue(me.confid);
 122         }
 123     },
 124
 125     setNodename: function(nodename) {
 126         var me = this;
 127         me.down('#hdstorage').setNodename(nodename);
 128         me.down('#hdimage').setStorage(undefined, nodename);
 129     },
 130
 131     initComponent : function() {
 132         var me = this;
 133
 134         var isroot = me.confid === 'rootfs';
 135
 136         me.mpdata = {};
 137
 138         me.column1 = [];
 139
 140         if (!me.confid || me.unused) {
 141             var names = [];
 142             var i;
 143             for (i = 0; i != 8; ++i) {
 144                 var name = 'mp' + i.toString();
 145                 names.push([name, name]);
 146             }
 147             me.mpsel = Ext.create('PVE.form.KVComboBox', {
 148                 name: 'mpsel',
 149                 fieldLabel: gettext('Mount Point'),
 150                 matchFieldWidth: false,
 151                 allowBlank: false,
 152                 comboItems: names,
 153                 validator: function(value) {
 154                     if (!me.rendered) {
 155                         return;
 156                     }
 157                     if (Ext.isDefined(me.vmconfig[value])) {
 158                         return "Mount point is already in use.";
 159                     }
 160                     /*jslint confusion: true*/
 161                     /* returns a string above */
 162                     return true;
 163                 },
 164                 listeners: {
 165                     change: function(field, value) {
 166                         field.validate();
 167                     }
 168                 }
 169             });
 170             me.column1.push(me.mpsel);
 171         }
 172
 173         me.column1.push({
 174             xtype: 'pveDiskStorageSelector',
 175             nodename: me.nodename,
 176             storageContent: 'rootdir',
 177             autoSelect: true,
 178             hidden: me.unused || !me.isCreate
 179         });
 180
 181         if (me.unused) {
 182             me.unusedDisks = Ext.create('PVE.form.KVComboBox', {
 183                 name: 'unusedId',
 184                 fieldLabel: gettext('Disk image'),
 185                 matchFieldWidth: false,
 186                 listConfig: {
 187                     width: 350
 188                 },
 189                 data: [],
 190                 allowBlank: false,
 191                 listeners: {
 192                     change: function(f, value) {
 193                         // make sure our buttons are enabled/disabled when switching
 194                         // between images on different storages:
 195                         var disk = me.vmconfig[value];
 196                         var storage = disk.split(':')[0];
 197                         me.down('#hdstorage').setValue(storage);
 198                     }
 199                 }
 200             });
 201             me.column1.push(me.unusedDisks);
 202         } else if (!me.isCreate) {
 203             me.column1.push({
 204                 xtype: 'textfield',
 205                 disabled: true,
 206                 submitValue: false,
 207                 fieldLabel: gettext('Disk image'),
 208                 name: 'file'
 209             });
 210         }
 211
 212         me.acl = Ext.createWidget('pveKVComboBox', {
 213             name: 'acl',
 214             fieldLabel: gettext('ACLs'),
 215             comboItems: [['Default', 'Default'], ['1', 'On'], ['0', 'Off']],
 216             value: 'Default',
 217             allowBlank: true
 218         });
 219
 220         me.quota = Ext.createWidget('pvecheckbox', {
 221             name: 'quota',
 222             defaultValue: 0,
 223             disabled: me.unprivileged,
 224             fieldLabel: gettext('Enable quota')
 225         });
 226
 227         me.column2 = [
 228             me.acl,
 229             me.quota
 230         ];
 231
 232         if (!isroot) {
 233             me.column2.splice(1, 0, {
 234                 xtype: 'pvecheckbox',
 235                 name: 'ro',
 236                 defaultValue: 0,
 237                 fieldLabel: gettext('Read-only'),
 238                 hidden: me.insideWizard
 239             });
 240
 241             me.backup = Ext.createWidget('pvecheckbox',{
 242                 xtype: 'pvecheckbox',
 243                 name: 'backup',
 244                 fieldLabel: gettext('Backup')
 245             });
 246             if (me.mpdata.type !== 'bind') {
 247                 me.column2.push(me.backup);
 248             }
 249             me.column2.push({
 250                 xtype: 'pvecheckbox',
 251                 name: 'noreplicate',
 252                 fieldLabel: gettext('Skip replication')
 253             });
 254             me.column2.push({
 255                 xtype: 'textfield',
 256                 name: 'mp',
 257                 value: '',
 258                 emptyText:  gettext('/some/path'),
 259                 allowBlank: false,
 260                 hidden: isroot,
 261                 fieldLabel: gettext('Path')
 262             });
 263         }
 264
 265         me.callParent();
 266
 267         if (me.unused || me.isCreate) {
 268             me.mon(me.down('#hdstorage'), 'change', function(field, newValue) {
 269                 if (!newValue) {
 270                     return;
 271                 }
 272                 var rec = field.store.getById(newValue);
 273                 if (!rec) {
 274                     return;
 275                 }
 276                 if (rec.data.type === 'zfs' || rec.data.type === 'zfspool') {
 277                     me.quota.setDisabled(true);
 278                     me.quota.setValue(false);
 279                 } else {
 280                     me.quota.setDisabled(me.unprivileged);
 281                 }
 282             });
 283         }
 284     }
 285 });
 286
 287 Ext.define('PVE.lxc.MountPointEdit', {
 288     extend: 'PVE.window.Edit',
 289
 290     unprivileged: false,
 291
 292     initComponent : function() {
 293         var me = this;
 294
 295         var nodename = me.pveSelNode.data.node;
 296         if (!nodename) {
 297             throw "no node name specified";
 298         }
 299
 300         var unused = me.confid && me.confid.match(/^unused\d+$/);
 301
 302         me.isCreate = me.confid ? unused : true;
 303
 304         var ipanel = Ext.create('PVE.lxc.MountPointInputPanel', {
 305             confid: me.confid,
 306             nodename: nodename,
 307             unused: unused,
 308             unprivileged: me.unprivileged,
 309             isCreate: me.isCreate
 310         });
 311
 312         var subject;
 313         if (unused) {
 314             subject = gettext('Unused Disk');
 315         } else if (me.isCreate) {
 316             subject = gettext('Mount Point');
 317         } else {
 318             subject = gettext('Mount Point') + ' (' + me.confid + ')';
 319         }
 320
 321         Ext.apply(me, {
 322             subject: subject,
 323             items: ipanel
 324         });
 325
 326         me.callParent();
 327
 328         me.load({
 329             success: function(response, options) {
 330                 ipanel.setVMConfig(response.result.data);
 331                 if (me.confid) {
 332                     /*jslint confusion: true*/
 333                     /*data is defined as array above*/
 334                     var value = response.result.data[me.confid];
 335                     /*jslint confusion: false*/
 336                     var mp = PVE.Parser.parseLxcMountPoint(value);
 337
 338                     if (!mp) {
 339                         Ext.Msg.alert(gettext('Error'), 'Unable to parse mount point options');
 340                         me.close();
 341                         return;
 342                     }
 343
 344                     ipanel.setMountPoint(mp);
 345                     me.isValid(); // trigger validation
 346                 }
 347             }
 348         });
 349     }
 350 });