www/manager6/lxc/MPEdit.js

   1 /*jslint confusion: true*/
   2 /* hidden: boolean and string
   3  * bind: function and object
   4  * disabled: boolean and string
   5  */
   6 Ext.define('PVE.lxc.MountPointInputPanel', {
   7     extend: 'Proxmox.panel.InputPanel',
   8     xtype: 'pveLxcMountPointInputPanel',
   9
  10     insideWizard: false,
  11
  12     onlineHelp: 'pct_container_storage',
  13
  14     unused: false, // add unused disk imaged
  15
  16     unprivileged: false,
  17
  18     vmconfig: {}, // used to select unused disks
  19
  20     setUnprivileged: function(unprivileged) {
  21         var me = this;
  22         var vm = me.getViewModel();
  23         me.unprivileged = unprivileged;
  24         vm.set('unpriv', unprivileged);
  25     },
  26
  27     onGetValues: function(values) {
  28         var me = this;
  29
  30         var confid = me.confid || "mp"+values.mpid;
  31         values.file = me.down('field[name=file]').getValue();
  32         if (values.mountoptions) {
  33             values.mountoptions = values.mountoptions.join(';');
  34         }
  35
  36         if (me.unused) {
  37             confid = "mp"+values.mpid;
  38         } else if (me.isCreate) {
  39             values.file = values.hdstorage + ':' + values.disksize;
  40         }
  41
  42         // delete unnecessary fields
  43         delete values.mpid;
  44         delete values.hdstorage;
  45         delete values.disksize;
  46         delete values.diskformat;
  47
  48         var res = {};
  49         res[confid] = PVE.Parser.printLxcMountPoint(values);
  50         return res;
  51     },
  52
  53
  54     setMountPoint: function(mp) {
  55         var me = this;
  56         var vm = this.getViewModel();
  57         vm.set('mptype', mp.type);
  58         if (mp.mountoptions) {
  59             mp.mountoptions = mp.mountoptions.split(';');
  60         }
  61
  62         if (this.confid === 'rootfs') {
  63             var field = me.down('field[name=mountoptions]');
  64             var forbidden = ['nodev', 'noexec'];
  65             var filtered = field.comboItems.filter(e => !forbidden.includes(e[0]));
  66             field.setComboItems(filtered);
  67         }
  68
  69         me.setValues(mp);
  70     },
  71
  72     setVMConfig: function(vmconfig) {
  73         var me = this;
  74         var vm = me.getViewModel();
  75         me.vmconfig = vmconfig;
  76         vm.set('unpriv', vmconfig.unprivileged);
  77
  78         PVE.Utils.forEachMP(function(bus, i) {
  79             var name = "mp" + i.toString();
  80             if (!Ext.isDefined(vmconfig[name])) {
  81                 me.down('field[name=mpid]').setValue(i);
  82                 return false;
  83             }
  84         });
  85     },
  86
  87     setNodename: function(nodename) {
  88         var me = this;
  89         var vm = me.getViewModel();
  90         vm.set('node', nodename);
  91         me.down('#diskstorage').setNodename(nodename);
  92     },
  93
  94     controller:  {
  95         xclass: 'Ext.app.ViewController',
  96
  97         control: {
  98             'field[name=mpid]': {
  99                 change: function(field, value) {
 100                     field.validate();
 101                 }
 102             },
 103             '#hdstorage': {
 104                 change: function(field, newValue) {
 105                     var me = this;
 106                     if (!newValue) {
 107                         return;
 108                     }
 109
 110                     var rec = field.store.getById(newValue);
 111                     if (!rec) {
 112                         return;
 113                     }
 114
 115                     var vm = me.getViewModel();
 116                     vm.set('type', rec.data.type);
 117                 }
 118             }
 119         },
 120
 121         init: function(view) {
 122             var me = this;
 123             var vm = this.getViewModel();
 124             vm.set('confid', view.confid);
 125             vm.set('unused', view.unused);
 126             vm.set('node', view.nodename);
 127             vm.set('unpriv', view.unprivileged);
 128             vm.set('hideStorSelector', view.unused || !view.isCreate);
 129         }
 130     },
 131
 132     viewModel: {
 133         data: {
 134             unpriv: false,
 135             unused: false,
 136             showStorageSelector: false,
 137             mptype: '',
 138             type: '',
 139             confid: '',
 140             node: ''
 141         },
 142
 143         formulas: {
 144             quota: function(get) {
 145                 return !(get('type') === 'zfs' ||
 146                          get('type') === 'zfspool' ||
 147                          get('unpriv') ||
 148                          get('isBind'));
 149             },
 150             hasMP: function(get) {
 151                 return !!get('confid') && !get('unused');
 152             },
 153             isRoot: function(get) {
 154                 return get('confid') === 'rootfs';
 155             },
 156             isBind: function(get) {
 157                 return get('mptype') === 'bind';
 158             },
 159             isBindOrRoot: function(get) {
 160                 return get('isBind') || get('isRoot');
 161             }
 162         }
 163     },
 164
 165     column1: [
 166         {
 167             xtype: 'proxmoxintegerfield',
 168             name: 'mpid',
 169             fieldLabel: gettext('Mount Point ID'),
 170             minValue: 0,
 171             maxValue: PVE.Utils.mp_counts.mps - 1,
 172             hidden: true,
 173             allowBlank: false,
 174             disabled: true,
 175             bind: {
 176                 hidden: '{hasMP}',
 177                 disabled: '{hasMP}'
 178             },
 179             validator: function(value) {
 180                 var me = this.up('inputpanel');
 181                 if (!me.rendered) {
 182                     return;
 183                 }
 184                 if (Ext.isDefined(me.vmconfig["mp"+value])) {
 185                     return "Mount point is already in use.";
 186                 }
 187                 /*jslint confusion: true*/
 188                 /* returns a string above */
 189                 return true;
 190             }
 191         },
 192         {
 193             xtype: 'pveDiskStorageSelector',
 194             itemId: 'diskstorage',
 195             storageContent: 'rootdir',
 196             hidden: true,
 197             autoSelect: true,
 198             selectformat: false,
 199             defaultSize: 8,
 200             bind: {
 201                 hidden: '{hideStorSelector}',
 202                 disabled: '{hideStorSelector}',
 203                 nodename: '{node}'
 204             }
 205         },
 206         {
 207             xtype: 'textfield',
 208             disabled: true,
 209             submitValue: false,
 210             fieldLabel: gettext('Disk image'),
 211             name: 'file',
 212             bind: {
 213                 hidden: '{!hideStorSelector}'
 214             }
 215         }
 216     ],
 217
 218     column2: [
 219         {
 220             xtype: 'textfield',
 221             name: 'mp',
 222             value: '',
 223             emptyText:  gettext('/some/path'),
 224             allowBlank: false,
 225             disabled: true,
 226             fieldLabel: gettext('Path'),
 227             bind: {
 228                 hidden: '{isRoot}',
 229                 disabled: '{isRoot}'
 230             }
 231         },
 232         {
 233             xtype: 'proxmoxcheckbox',
 234             name: 'backup',
 235             fieldLabel: gettext('Backup'),
 236             bind: {
 237                 hidden: '{isRoot}',
 238                 disabled: '{isBindOrRoot}'
 239             }
 240         }
 241     ],
 242
 243     advancedColumn1: [
 244         {
 245             xtype: 'proxmoxcheckbox',
 246             name: 'quota',
 247             defaultValue: 0,
 248             bind: {
 249                 disabled: '{!quota}'
 250             },
 251             fieldLabel: gettext('Enable quota'),
 252             listeners: {
 253                 disable: function() {
 254                     this.reset();
 255                 }
 256             }
 257         },
 258         {
 259             xtype: 'proxmoxcheckbox',
 260             name: 'ro',
 261             defaultValue: 0,
 262             bind: {
 263                 hidden: '{isRoot}',
 264                 disabled: '{isRoot}'
 265             },
 266             fieldLabel: gettext('Read-only')
 267         },
 268         {
 269             xtype: 'proxmoxKVComboBox',
 270             name: 'mountoptions',
 271             fieldLabel: gettext('Mount options'),
 272             deleteEmpty: false,
 273             comboItems: [
 274                 ['noatime', 'noatime'],
 275                 ['nodev', 'nodev'],
 276                 ['noexec', 'noexec'],
 277                 ['nosuid', 'nosuid']
 278             ],
 279             multiSelect: true,
 280             value: [],
 281             allowBlank: true
 282         },
 283     ],
 284
 285     advancedColumn2: [
 286         {
 287             xtype: 'proxmoxKVComboBox',
 288             name: 'acl',
 289             fieldLabel: 'ACLs',
 290             deleteEmpty: false,
 291             comboItems: [
 292                 ['__default__', Proxmox.Utils.defaultText],
 293                 ['1', Proxmox.Utils.enabledText],
 294                 ['0', Proxmox.Utils.disabledText]
 295             ],
 296             value: '__default__',
 297             bind: {
 298                 disabled: '{isBind}'
 299             },
 300             allowBlank: true
 301         },
 302         {
 303             xtype: 'proxmoxcheckbox',
 304             inputValue: '0', // reverses the logic
 305             name: 'replicate',
 306             fieldLabel: gettext('Skip replication')
 307         }
 308     ]
 309 });
 310
 311 Ext.define('PVE.lxc.MountPointEdit', {
 312     extend: 'Proxmox.window.Edit',
 313
 314     unprivileged: false,
 315
 316     initComponent : function() {
 317         var me = this;
 318
 319         var nodename = me.pveSelNode.data.node;
 320         if (!nodename) {
 321             throw "no node name specified";
 322         }
 323
 324         var unused = me.confid && me.confid.match(/^unused\d+$/);
 325
 326         me.isCreate = me.confid ? unused : true;
 327
 328         var ipanel = Ext.create('PVE.lxc.MountPointInputPanel', {
 329             confid: me.confid,
 330             nodename: nodename,
 331             unused: unused,
 332             unprivileged: me.unprivileged,
 333             isCreate: me.isCreate
 334         });
 335
 336         var subject;
 337         if (unused) {
 338             subject = gettext('Unused Disk');
 339         } else if (me.isCreate) {
 340             subject = gettext('Mount Point');
 341         } else {
 342             subject = gettext('Mount Point') + ' (' + me.confid + ')';
 343         }
 344
 345         Ext.apply(me, {
 346             subject: subject,
 347             defaultFocus: me.confid !== 'rootfs' ? 'textfield[name=mp]' : 'tool',
 348             items: ipanel
 349         });
 350
 351         me.callParent();
 352
 353         me.load({
 354             success: function(response, options) {
 355                 ipanel.setVMConfig(response.result.data);
 356                 if (me.confid) {
 357                     /*jslint confusion: true*/
 358                     /*data is defined as array above*/
 359                     var value = response.result.data[me.confid];
 360                     /*jslint confusion: false*/
 361                     var mp = PVE.Parser.parseLxcMountPoint(value);
 362
 363                     if (!mp) {
 364                         Ext.Msg.alert(gettext('Error'), 'Unable to parse mount point options');
 365                         me.close();
 366                         return;
 367                     }
 368
 369                     ipanel.setMountPoint(mp);
 370                     me.isValid(); // trigger validation
 371                 }
 372             }
 373         });
 374     }
 375 });