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
  33         if (me.unused) {
  34             confid = "mp"+values.mpid;
  35         } else if (me.isCreate) {
  36             values.file = values.hdstorage + ':' + values.disksize;
  37         }
  38
  39         // delete unnecessary fields
  40         delete values.mpid;
  41         delete values.hdstorage;
  42         delete values.disksize;
  43         delete values.diskformat;
  44
  45         var res = {};
  46         res[confid] = PVE.Parser.printLxcMountPoint(values);
  47         return res;
  48     },
  49
  50
  51     setMountPoint: function(mp) {
  52         var me = this;
  53         var vm = this.getViewModel();
  54         vm.set('mptype', mp.type);
  55         me.setValues(mp);
  56     },
  57
  58     setVMConfig: function(vmconfig) {
  59         var me = this;
  60         var vm = me.getViewModel();
  61         me.vmconfig = vmconfig;
  62         vm.set('unpriv', vmconfig.unprivileged);
  63         vm.notify();
  64
  65         PVE.Utils.forEachMP(function(bus, i) {
  66             var name = "mp" + i.toString();
  67             if (!Ext.isDefined(vmconfig[name])) {
  68                 me.down('field[name=mpid]').setValue(i);
  69                 return false;
  70             }
  71         });
  72     },
  73
  74     setNodename: function(nodename) {
  75         var me = this;
  76         var vm = me.getViewModel();
  77         vm.set('node', nodename);
  78         vm.notify();
  79         me.down('#diskstorage').setNodename(nodename);
  80     },
  81
  82     controller:  {
  83         xclass: 'Ext.app.ViewController',
  84
  85         control: {
  86             'field[name=mpid]': {
  87                 change: function(field, value) {
  88                     field.validate();
  89                 }
  90             },
  91             '#hdstorage': {
  92                 change: function(field, newValue) {
  93                     var me = this;
  94                     if (!newValue) {
  95                         return;
  96                     }
  97
  98                     var rec = field.store.getById(newValue);
  99                     if (!rec) {
 100                         return;
 101                     }
 102
 103                     var vm = me.getViewModel();
 104                     vm.set('type', rec.data.type);
 105                     vm.notify();
 106                 }
 107             }
 108         },
 109
 110         init: function(view) {
 111             var me = this;
 112             var vm = this.getViewModel();
 113             vm.set('confid', view.confid);
 114             vm.set('unused', view.unused);
 115             vm.set('node', view.nodename);
 116             vm.set('unpriv', view.unprivileged);
 117             vm.set('hideStorSelector', view.unused || !view.isCreate);
 118             vm.notify();
 119         }
 120     },
 121
 122     viewModel: {
 123         data: {
 124             unpriv: false,
 125             unused: false,
 126             showStorageSelector: false,
 127             mptype: '',
 128             type: '',
 129             confid: '',
 130             node: ''
 131         },
 132
 133         formulas: {
 134             quota: function(get) {
 135                 return !(get('type') === 'zfs' ||
 136                          get('type') === 'zfspool' ||
 137                          get('unpriv') ||
 138                          get('isBind'));
 139             },
 140             hasMP: function(get) {
 141                 return !!get('confid') && !get('unused');
 142             },
 143             isRoot: function(get) {
 144                 return get('confid') === 'rootfs';
 145             },
 146             isBind: function(get) {
 147                 return get('mptype') === 'bind';
 148             },
 149             isBindOrRoot: function(get) {
 150                 return get('isBind') || get('isRoot');
 151             }
 152         }
 153     },
 154
 155     column1: [
 156         {
 157             xtype: 'proxmoxintegerfield',
 158             name: 'mpid',
 159             fieldLabel: gettext('Mount Point ID'),
 160             minValue: 0,
 161             maxValue: PVE.Utils.mp_counts.mps - 1,
 162             hidden: true,
 163             allowBlank: false,
 164             disabled: true,
 165             bind: {
 166                 hidden: '{hasMP}',
 167                 disabled: '{hasMP}'
 168             },
 169             validator: function(value) {
 170                 var me = this.up('inputpanel');
 171                 if (!me.rendered) {
 172                     return;
 173                 }
 174                 if (Ext.isDefined(me.vmconfig["mp"+value])) {
 175                     return "Mount point is already in use.";
 176                 }
 177                 /*jslint confusion: true*/
 178                 /* returns a string above */
 179                 return true;
 180             }
 181         },
 182         {
 183             xtype: 'pveDiskStorageSelector',
 184             itemId: 'diskstorage',
 185             storageContent: 'rootdir',
 186             hidden: true,
 187             autoSelect: true,
 188             selectformat: false,
 189             defaultSize: 8,
 190             bind: {
 191                 hidden: '{hideStorSelector}',
 192                 disabled: '{hideStorSelector}',
 193                 nodename: '{node}'
 194             }
 195         },
 196         {
 197             xtype: 'textfield',
 198             disabled: true,
 199             submitValue: false,
 200             fieldLabel: gettext('Disk image'),
 201             name: 'file',
 202             bind: {
 203                 hidden: '{!hideStorSelector}'
 204             }
 205         }
 206     ],
 207
 208     column2: [
 209         {
 210             xtype: 'textfield',
 211             name: 'mp',
 212             value: '',
 213             emptyText:  gettext('/some/path'),
 214             allowBlank: false,
 215             disabled: true,
 216             fieldLabel: gettext('Path'),
 217             bind: {
 218                 hidden: '{isRoot}',
 219                 disabled: '{isRoot}'
 220             }
 221         },
 222         {
 223             xtype: 'proxmoxcheckbox',
 224             name: 'backup',
 225             fieldLabel: gettext('Backup'),
 226             bind: {
 227                 hidden: '{isRoot}',
 228                 disabled: '{isBindOrRoot}'
 229             }
 230         }
 231     ],
 232
 233     advancedColumn1: [
 234         {
 235             xtype: 'proxmoxcheckbox',
 236             name: 'quota',
 237             defaultValue: 0,
 238             bind: {
 239                 disabled: '{!quota}'
 240             },
 241             fieldLabel: gettext('Enable quota'),
 242             listeners: {
 243                 disable: function() {
 244                     this.reset();
 245                 }
 246             }
 247         },
 248         {
 249             xtype: 'proxmoxcheckbox',
 250             name: 'ro',
 251             defaultValue: 0,
 252             bind: {
 253                 hidden: '{isRoot}',
 254                 disabled: '{isRoot}'
 255             },
 256             fieldLabel: gettext('Read-only')
 257         }
 258     ],
 259
 260     advancedColumn2: [
 261         {
 262             xtype: 'proxmoxKVComboBox',
 263             name: 'acl',
 264             fieldLabel: 'ACLs',
 265             deleteEmpty: false,
 266             comboItems: [
 267                 ['__default__', Proxmox.Utils.defaultText],
 268                 ['1', Proxmox.Utils.enabledText],
 269                 ['0', Proxmox.Utils.disabledText]
 270             ],
 271             value: '__default__',
 272             bind: {
 273                 disabled: '{isBind}'
 274             },
 275             allowBlank: true
 276         },
 277         {
 278             xtype: 'proxmoxcheckbox',
 279             inputValue: '0', // reverses the logic
 280             name: 'replicate',
 281             fieldLabel: gettext('Skip replication')
 282         }
 283     ]
 284 });
 285
 286 Ext.define('PVE.lxc.MountPointEdit', {
 287     extend: 'Proxmox.window.Edit',
 288
 289     unprivileged: false,
 290
 291     initComponent : function() {
 292         var me = this;
 293
 294         var nodename = me.pveSelNode.data.node;
 295         if (!nodename) {
 296             throw "no node name specified";
 297         }
 298
 299         var unused = me.confid && me.confid.match(/^unused\d+$/);
 300
 301         me.isCreate = me.confid ? unused : true;
 302
 303         var ipanel = Ext.create('PVE.lxc.MountPointInputPanel', {
 304             confid: me.confid,
 305             nodename: nodename,
 306             unused: unused,
 307             unprivileged: me.unprivileged,
 308             isCreate: me.isCreate
 309         });
 310
 311         var subject;
 312         if (unused) {
 313             subject = gettext('Unused Disk');
 314         } else if (me.isCreate) {
 315             subject = gettext('Mount Point');
 316         } else {
 317             subject = gettext('Mount Point') + ' (' + me.confid + ')';
 318         }
 319
 320         Ext.apply(me, {
 321             subject: subject,
 322             defaultFocus: me.confid !== 'rootfs' ? 'textfield[name=mp]' : 'tool',
 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 });