-/*jslint confusion: true*/
-/* hidden: boolean and string
- * bind: function and object
- * disabled: boolean and string
- */
Ext.define('PVE.lxc.MountPointInputPanel', {
extend: 'Proxmox.panel.InputPanel',
xtype: 'pveLxcMountPointInputPanel',
- insideWizard: false,
-
onlineHelp: 'pct_container_storage',
- unused: false, // add unused disk imaged
+ insideWizard: false,
+ unused: false, // add unused disk imaged
unprivileged: false,
vmconfig: {}, // used to select unused disks
delete values.disksize;
delete values.diskformat;
- let mountopts = (values.mountoptions || []).join(';');
- PVE.Utils.propertyStringSet(me.mp, values.mp, 'mp');
- PVE.Utils.propertyStringSet(me.mp, values.mountoptions, 'mountoptions', mountopts);
- PVE.Utils.propertyStringSet(me.mp, values.backup, 'backup');
- PVE.Utils.propertyStringSet(me.mp, values.quota, 'quota');
- PVE.Utils.propertyStringSet(me.mp, values.ro, 'ro');
- PVE.Utils.propertyStringSet(me.mp, values.acl, 'acl');
- PVE.Utils.propertyStringSet(me.mp, values.replicate, 'replicate');
+ let setMPOpt = (k, src, v) => PVE.Utils.propertyStringSet(me.mp, src, k, v);
- var res = {};
+ setMPOpt('mp', values.mp);
+ let mountOpts = (values.mountoptions || []).join(';');
+ setMPOpt('mountoptions', values.mountoptions, mountOpts);
+ setMPOpt('mp', values.mp);
+ setMPOpt('backup', values.backup);
+ setMPOpt('quota', values.quota);
+ setMPOpt('ro', values.ro);
+ setMPOpt('acl', values.acl);
+ setMPOpt('replicate', values.replicate);
+
+ let res = {};
res[confid] = PVE.Parser.printLxcMountPoint(me.mp);
return res;
},
-
setMountPoint: function(mp) {
- var me = this;
- var vm = this.getViewModel();
+ let me = this;
+ let vm = me.getViewModel();
vm.set('mptype', mp.type);
if (mp.mountoptions) {
mp.mountoptions = mp.mountoptions.split(';');
}
me.mp = mp;
+ me.filterMountOptions();
+ me.setValues(mp);
+ },
- if (this.confid === 'rootfs') {
- var field = me.down('field[name=mountoptions]');
- var forbidden = ['nodev', 'noexec'];
- var filtered = field.comboItems.filter(e => !forbidden.includes(e[0]));
+ filterMountOptions: function() {
+ let me = this;
+ if (me.confid === 'rootfs') {
+ let field = me.down('field[name=mountoptions]');
+ let exclude = ['nodev', 'noexec'];
+ let filtered = field.comboItems.filter(v => !exclude.includes(v[0]));
field.setComboItems(filtered);
}
-
- me.setValues(mp);
},
- setVMConfig: function(vmconfig) {
- var me = this;
- var vm = me.getViewModel();
+ updateVMConfig: function(vmconfig) {
+ let me = this;
+ let vm = me.getViewModel();
me.vmconfig = vmconfig;
vm.set('unpriv', vmconfig.unprivileged);
+ me.down('field[name=mpid]').validate();
+ },
- PVE.Utils.forEachMP(function(bus, i) {
- var name = "mp" + i.toString();
+ setVMConfig: function(vmconfig) {
+ let me = this;
+
+ me.updateVMConfig(vmconfig);
+ PVE.Utils.forEachMP((bus, i) => {
+ let name = "mp" + i.toString();
if (!Ext.isDefined(vmconfig[name])) {
me.down('field[name=mpid]').setValue(i);
return false;
}
+ return undefined;
});
},
setNodename: function(nodename) {
- var me = this;
- var vm = me.getViewModel();
+ let me = this;
+ let vm = me.getViewModel();
vm.set('node', nodename);
me.down('#diskstorage').setNodename(nodename);
},
- controller: {
+ controller: {
xclass: 'Ext.app.ViewController',
control: {
'field[name=mpid]': {
change: function(field, value) {
+ let me = this;
+ let view = this.getView();
+ if (view.confid !== 'rootfs') {
+ view.fireEvent('diskidchange', view, `mp${value}`);
+ }
field.validate();
- }
+ },
},
'#hdstorage': {
change: function(field, newValue) {
- var me = this;
+ let me = this;
if (!newValue) {
return;
}
- var rec = field.store.getById(newValue);
+ let rec = field.store.getById(newValue);
if (!rec) {
return;
}
-
- var vm = me.getViewModel();
- vm.set('type', rec.data.type);
- }
- }
+ me.getViewModel().set('type', rec.data.type);
+ },
+ },
},
-
init: function(view) {
- var me = this;
- var vm = this.getViewModel();
+ let me = this;
+ let vm = this.getViewModel();
view.mp = {};
vm.set('confid', view.confid);
vm.set('unused', view.unused);
vm.set('node', view.nodename);
vm.set('unpriv', view.unprivileged);
vm.set('hideStorSelector', view.unused || !view.isCreate);
- }
+
+ if (view.isCreate) { // can be array if created from unused disk
+ vm.set('isIncludedInBackup', true);
+ if (view.insideWizard) {
+ view.filterMountOptions();
+ }
+ }
+ if (view.selectFree) {
+ view.setVMConfig(view.vmconfig);
+ }
+ },
},
viewModel: {
mptype: '',
type: '',
confid: '',
- node: ''
+ node: '',
},
formulas: {
},
isBindOrRoot: function(get) {
return get('isBind') || get('isRoot');
- }
- }
+ },
+ },
},
column1: [
name: 'mpid',
fieldLabel: gettext('Mount Point ID'),
minValue: 0,
- maxValue: PVE.Utils.mp_counts.mps - 1,
+ maxValue: PVE.Utils.mp_counts.mp - 1,
hidden: true,
allowBlank: false,
disabled: true,
bind: {
hidden: '{hasMP}',
- disabled: '{hasMP}'
+ disabled: '{hasMP}',
},
validator: function(value) {
- var me = this.up('inputpanel');
- if (!me.rendered) {
- return;
+ let view = this.up('inputpanel');
+ if (!view.rendered) {
+ return undefined;
}
- if (Ext.isDefined(me.vmconfig["mp"+value])) {
+ if (Ext.isDefined(view.vmconfig["mp"+value])) {
return "Mount point is already in use.";
}
- /*jslint confusion: true*/
- /* returns a string above */
return true;
- }
+ },
},
{
xtype: 'pveDiskStorageSelector',
bind: {
hidden: '{hideStorSelector}',
disabled: '{hideStorSelector}',
- nodename: '{node}'
- }
+ nodename: '{node}',
+ },
},
{
xtype: 'textfield',
fieldLabel: gettext('Disk image'),
name: 'file',
bind: {
- hidden: '{!hideStorSelector}'
- }
- }
+ hidden: '{!hideStorSelector}',
+ },
+ },
],
column2: [
xtype: 'textfield',
name: 'mp',
value: '',
- emptyText: gettext('/some/path'),
+ emptyText: gettext('/some/path'),
allowBlank: false,
disabled: true,
fieldLabel: gettext('Path'),
bind: {
hidden: '{isRoot}',
- disabled: '{isRoot}'
- }
+ disabled: '{isRoot}',
+ },
},
{
xtype: 'proxmoxcheckbox',
name: 'backup',
fieldLabel: gettext('Backup'),
+ autoEl: {
+ tag: 'div',
+ 'data-qtip': gettext('Include volume in backup job'),
+ },
bind: {
hidden: '{isRoot}',
- disabled: '{isBindOrRoot}'
- }
- }
+ disabled: '{isBindOrRoot}',
+ value: '{isIncludedInBackup}',
+ },
+ },
],
advancedColumn1: [
name: 'quota',
defaultValue: 0,
bind: {
- disabled: '{!quota}'
+ disabled: '{!quota}',
},
fieldLabel: gettext('Enable quota'),
listeners: {
disable: function() {
this.reset();
- }
- }
+ },
+ },
},
{
xtype: 'proxmoxcheckbox',
defaultValue: 0,
bind: {
hidden: '{isRoot}',
- disabled: '{isRoot}'
+ disabled: '{isRoot}',
},
- fieldLabel: gettext('Read-only')
+ fieldLabel: gettext('Read-only'),
},
{
xtype: 'proxmoxKVComboBox',
fieldLabel: gettext('Mount options'),
deleteEmpty: false,
comboItems: [
+ ['lazytime', 'lazytime'],
['noatime', 'noatime'],
['nodev', 'nodev'],
['noexec', 'noexec'],
- ['nosuid', 'nosuid']
+ ['nosuid', 'nosuid'],
],
multiSelect: true,
value: [],
- allowBlank: true
+ allowBlank: true,
},
],
comboItems: [
['__default__', Proxmox.Utils.defaultText],
['1', Proxmox.Utils.enabledText],
- ['0', Proxmox.Utils.disabledText]
+ ['0', Proxmox.Utils.disabledText],
],
value: '__default__',
bind: {
- disabled: '{isBind}'
+ disabled: '{isBind}',
},
- allowBlank: true
+ allowBlank: true,
},
{
xtype: 'proxmoxcheckbox',
inputValue: '0', // reverses the logic
name: 'replicate',
- fieldLabel: gettext('Skip replication')
- }
- ]
+ fieldLabel: gettext('Skip replication'),
+ },
+ ],
});
Ext.define('PVE.lxc.MountPointEdit', {
unprivileged: false,
- initComponent : function() {
- var me = this;
+ initComponent: function() {
+ let me = this;
- var nodename = me.pveSelNode.data.node;
+ let nodename = me.pveSelNode.data.node;
if (!nodename) {
throw "no node name specified";
}
- var unused = me.confid && me.confid.match(/^unused\d+$/);
+ let unused = me.confid && me.confid.match(/^unused\d+$/);
me.isCreate = me.confid ? unused : true;
- var ipanel = Ext.create('PVE.lxc.MountPointInputPanel', {
+ let ipanel = Ext.create('PVE.lxc.MountPointInputPanel', {
confid: me.confid,
nodename: nodename,
unused: unused,
unprivileged: me.unprivileged,
- isCreate: me.isCreate
+ isCreate: me.isCreate,
});
- var subject;
+ let subject;
if (unused) {
subject = gettext('Unused Disk');
} else if (me.isCreate) {
Ext.apply(me, {
subject: subject,
defaultFocus: me.confid !== 'rootfs' ? 'textfield[name=mp]' : 'tool',
- items: ipanel
+ items: ipanel,
});
me.callParent();
me.load({
success: function(response, options) {
ipanel.setVMConfig(response.result.data);
- if (me.confid) {
- /*jslint confusion: true*/
- /*data is defined as array above*/
- var value = response.result.data[me.confid];
- /*jslint confusion: false*/
- var mp = PVE.Parser.parseLxcMountPoint(value);
+ if (me.confid) {
+ let value = response.result.data[me.confid];
+ let mp = PVE.Parser.parseLxcMountPoint(value);
if (!mp) {
Ext.Msg.alert(gettext('Error'), 'Unable to parse mount point options');
me.close();
return;
}
-
ipanel.setMountPoint(mp);
me.isValid(); // trigger validation
}
- }
+ },
});
- }
+ },
});
projects / pve-manager.git / blobdiff