node/NetworkEdit.js

   1 Ext.define('Proxmox.node.NetworkEdit', {
   2     extend: 'Proxmox.window.Edit',
   3     alias: ['widget.proxmoxNodeNetworkEdit'],
   4
   5     initComponent : function() {
   6         var me = this;
   7
   8         if (!me.nodename) {
   9             throw "no node name specified";
  10         }
  11
  12         if (!me.iftype) {
  13             throw "no network device type specified";
  14         }
  15
  16         me.isCreate = !me.iface;
  17
  18         var iface_vtype;
  19
  20         if (me.iftype === 'bridge') {
  21             iface_vtype = 'BridgeName';
  22         } else if (me.iftype === 'bond') {
  23             iface_vtype = 'BondName';
  24         } else if (me.iftype === 'eth' && !me.isCreate) {
  25             iface_vtype = 'InterfaceName';
  26         } else if (me.iftype === 'vlan') {
  27             iface_vtype = 'VlanName';
  28         } else if (me.iftype === 'OVSBridge') {
  29             iface_vtype = 'BridgeName';
  30         } else if (me.iftype === 'OVSBond') {
  31             iface_vtype = 'BondName';
  32         } else if (me.iftype === 'OVSIntPort') {
  33             iface_vtype = 'InterfaceName';
  34         } else if (me.iftype === 'OVSPort') {
  35             iface_vtype = 'InterfaceName';
  36         } else {
  37             console.log(me.iftype);
  38             throw "unknown network device type specified";
  39         }
  40
  41         me.subject = Proxmox.Utils.render_network_iface_type(me.iftype);
  42
  43         let column1 = [],
  44             column2 = [],
  45             advancedColumn1 = [],
  46             advancedColumn2 = [];
  47
  48         if (!(me.iftype === 'OVSIntPort' || me.iftype === 'OVSPort' || me.iftype === 'OVSBond')) {
  49             column2.push({
  50                 xtype: 'proxmoxcheckbox',
  51                 fieldLabel: gettext('Autostart'),
  52                 name: 'autostart',
  53                 uncheckedValue: 0,
  54                 checked: me.isCreate ? true : undefined
  55             });
  56         }
  57
  58         if (me.iftype === 'bridge') {
  59             column2.push({
  60                 xtype: 'proxmoxcheckbox',
  61                 fieldLabel: gettext('VLAN aware'),
  62                 name: 'bridge_vlan_aware',
  63                 deleteEmpty: !me.isCreate
  64             });
  65             column2.push({
  66                 xtype: 'textfield',
  67                 fieldLabel: gettext('Bridge ports'),
  68                 name: 'bridge_ports'
  69             });
  70         } else if (me.iftype === 'OVSBridge') {
  71             column2.push({
  72                 xtype: 'textfield',
  73                 fieldLabel: gettext('Bridge ports'),
  74                 name: 'ovs_ports'
  75             });
  76             column2.push({
  77                 xtype: 'textfield',
  78                 fieldLabel: gettext('OVS options'),
  79                 name: 'ovs_options'
  80             });
  81         } else if (me.iftype === 'OVSPort' || me.iftype === 'OVSIntPort') {
  82             column2.push({
  83                 xtype: me.isCreate ? 'PVE.form.BridgeSelector' : 'displayfield',
  84                 fieldLabel: Proxmox.Utils.render_network_iface_type('OVSBridge'),
  85                 allowBlank: false,
  86                 nodename: me.nodename,
  87                 bridgeType: 'OVSBridge',
  88                 name: 'ovs_bridge'
  89             });
  90             column2.push({
  91                 xtype: 'pveVlanField',
  92                 deleteEmpty: !me.isCreate,
  93                 name: 'ovs_tag',
  94                 value: ''
  95             });
  96             column2.push({
  97                 xtype: 'textfield',
  98                 fieldLabel: gettext('OVS options'),
  99                 name: 'ovs_options'
 100             });
 101         } else if (me.iftype === 'vlan') {
 102
 103             if (!me.isCreate) {
 104
 105                 me.disablevlanid = false;
 106                 me.disablevlanrawdevice = false;
 107                 me.vlanrawdevicevalue = '';
 108                 me.vlanidvalue = '';
 109
 110                 if (Proxmox.Utils.VlanInterface_match.test(me.iface)) {
 111                    me.disablevlanid = true;
 112                    me.disablevlanrawdevice = true;
 113                    var arr = Proxmox.Utils.VlanInterface_match.exec(me.iface);
 114                    me.vlanrawdevicevalue = arr[1];
 115                    me.vlanidvalue = arr[2];
 116
 117                 } else if (Proxmox.Utils.Vlan_match.test(me.iface)) {
 118                    me.disablevlanid = true;
 119                    var arr = Proxmox.Utils.Vlan_match.exec(me.iface);
 120                    me.vlanidvalue = arr[1];
 121                 }
 122             } else {
 123
 124                 me.disablevlanid = true;
 125                 me.disablevlanrawdevice = true;
 126            }
 127
 128             column2.push({
 129                 xtype: 'textfield',
 130                 fieldLabel: gettext('Vlan raw device'),
 131                 name: 'vlan-raw-device',
 132                 value: me.vlanrawdevicevalue,
 133                 disabled: me.disablevlanrawdevice
 134             });
 135
 136             column2.push({
 137                 xtype: 'pveVlanField',
 138                 name: 'vlan-id',
 139                 value: me.vlanidvalue,
 140                 disabled: me.disablevlanid
 141
 142             });
 143
 144         } else if (me.iftype === 'bond') {
 145             column2.push({
 146                 xtype: 'textfield',
 147                 fieldLabel: gettext('Slaves'),
 148                 name: 'slaves'
 149             });
 150
 151             var policySelector = Ext.createWidget('bondPolicySelector', {
 152                 fieldLabel: gettext('Hash policy'),
 153                 name: 'bond_xmit_hash_policy',
 154                 deleteEmpty: !me.isCreate,
 155                 disabled: true
 156             });
 157
 158             var primaryfield = Ext.createWidget('textfield', {
 159                 fieldLabel: gettext('bond-primary'),
 160                 name: 'bond-primary',
 161                 value: '',
 162                 disabled: true
 163             });
 164
 165             column2.push({
 166                 xtype: 'bondModeSelector',
 167                 fieldLabel: gettext('Mode'),
 168                 name: 'bond_mode',
 169                 value: me.isCreate ? 'balance-rr' : undefined,
 170                 listeners: {
 171                     change: function(f, value) {
 172                         if (value === 'balance-xor' ||
 173                             value === '802.3ad') {
 174                             policySelector.setDisabled(false);
 175                             primaryfield.setDisabled(true);
 176                             primaryfield.setValue('');
 177                         } else if (value === 'active-backup') {
 178                             primaryfield.setDisabled(false);
 179                             policySelector.setDisabled(true);
 180                             policySelector.setValue('');
 181                         } else {
 182                             policySelector.setDisabled(true);
 183                             policySelector.setValue('');
 184                             primaryfield.setDisabled(true);
 185                             primaryfield.setValue('');
 186                         }
 187                     }
 188                 },
 189                 allowBlank: false
 190             });
 191
 192             column2.push(policySelector);
 193             column2.push(primaryfield);
 194
 195         } else if (me.iftype === 'OVSBond') {
 196             column2.push({
 197                 xtype: me.isCreate ? 'PVE.form.BridgeSelector' : 'displayfield',
 198                 fieldLabel: Proxmox.Utils.render_network_iface_type('OVSBridge'),
 199                 allowBlank: false,
 200                 nodename: me.nodename,
 201                 bridgeType: 'OVSBridge',
 202                 name: 'ovs_bridge'
 203             });
 204             column2.push({
 205                 xtype: 'pveVlanField',
 206                 deleteEmpty: !me.isCreate,
 207                 name: 'ovs_tag',
 208                 value: ''
 209             });
 210             column2.push({
 211                 xtype: 'textfield',
 212                 fieldLabel: gettext('OVS options'),
 213                 name: 'ovs_options'
 214             });
 215         }
 216
 217         column2.push({
 218             xtype: 'textfield',
 219             fieldLabel: gettext('Comment'),
 220             allowBlank: true,
 221             nodename: me.nodename,
 222             name: 'comments'
 223         });
 224
 225         var url;
 226         var method;
 227
 228         if (me.isCreate) {
 229             url = "/api2/extjs/nodes/" + me.nodename + "/network";
 230             method = 'POST';
 231         } else {
 232             url = "/api2/extjs/nodes/" + me.nodename + "/network/" + me.iface;
 233             method = 'PUT';
 234         }
 235
 236         column1.push({
 237             xtype: 'hiddenfield',
 238             name: 'type',
 239             value: me.iftype
 240         },
 241         {
 242             xtype: me.isCreate ? 'textfield' : 'displayfield',
 243             fieldLabel: gettext('Name'),
 244             name: 'iface',
 245             value: me.iface,
 246             vtype: iface_vtype,
 247             allowBlank: false,
 248             listeners: {
 249                 change: function(f, value) {
 250                     if (me.isCreate && iface_vtype === 'VlanName') {
 251                         var vlanidField = me.down('field[name=vlan-id]');
 252                         var vlanrawdeviceField = me.down('field[name=vlan-raw-device]');
 253                         if (Proxmox.Utils.VlanInterface_match.test(value)) {
 254                             vlanidField.setDisabled(true);
 255                             vlanrawdeviceField.setDisabled(true);
 256                         } else if (Proxmox.Utils.Vlan_match.test(value)) {
 257                             vlanidField.setDisabled(true);
 258                             vlanrawdeviceField.setDisabled(false);
 259                         } else {
 260                             vlanidField.setDisabled(false);
 261                             vlanrawdeviceField.setDisabled(false);
 262                         }
 263                     }
 264                 }
 265             }
 266         });
 267
 268         if (me.iftype === 'OVSBond') {
 269             column1.push(
 270                 {
 271                     xtype: 'bondModeSelector',
 272                     fieldLabel: gettext('Mode'),
 273                     name: 'bond_mode',
 274                     openvswitch: true,
 275                     value: me.isCreate ? 'active-backup' : undefined,
 276                     allowBlank: false
 277                 },
 278                 {
 279                     xtype: 'textfield',
 280                     fieldLabel: gettext('Slaves'),
 281                     name: 'ovs_bonds'
 282                 }
 283             );
 284         } else {
 285
 286             column1.push(
 287                 {
 288                     xtype: 'proxmoxtextfield',
 289                     deleteEmpty: !me.isCreate,
 290                     fieldLabel: 'IPv4/CIDR',
 291                     vtype: 'IPCIDRAddress',
 292                     name: 'cidr'
 293                 },
 294                 {
 295                     xtype: 'proxmoxtextfield',
 296                     deleteEmpty: !me.isCreate,
 297                     fieldLabel: gettext('Gateway') + ' (IPv4)',
 298                     vtype: 'IPAddress',
 299                     name: 'gateway'
 300                 },
 301                 {
 302                     xtype: 'proxmoxtextfield',
 303                     deleteEmpty: !me.isCreate,
 304                     fieldLabel: 'IPv6/CIDR',
 305                     vtype: 'IP6CIDRAddress',
 306                     name: 'cidr6'
 307                 },
 308                 {
 309                     xtype: 'proxmoxtextfield',
 310                     deleteEmpty: !me.isCreate,
 311                     fieldLabel: gettext('Gateway') + ' (IPv6)',
 312                     vtype: 'IP6Address',
 313                     name: 'gateway6'
 314                 },
 315             );
 316             advancedColumn1. push(
 317                 {
 318                     xtype: 'proxmoxintegerfield',
 319                     minValue: 1280,
 320                     maxValue: 65520,
 321                     deleteEmpty: !me.isCreate,
 322                     emptyText: 1500,
 323                     fieldLabel: 'MTU',
 324                     name: 'mtu'
 325                 },
 326             );
 327         }
 328
 329         Ext.applyIf(me, {
 330             url: url,
 331             method: method,
 332             items: {
 333                 xtype: 'inputpanel',
 334                 column1: column1,
 335                 column2: column2,
 336                 advancedColumn1: advancedColumn1,
 337                 advancedColumn2: advancedColumn2,
 338             }
 339         });
 340
 341         me.callParent();
 342
 343         if (me.isCreate) {
 344             me.down('field[name=iface]').setValue(me.iface_default);
 345         } else {
 346             me.load({
 347                 success: function(response, options) {
 348                     var data = response.result.data;
 349                     if (data.type !== me.iftype) {
 350                         var msg = "Got unexpected device type";
 351                         Ext.Msg.alert(gettext('Error'), msg, function() {
 352                             me.close();
 353                         });
 354                         return;
 355                     }
 356                     me.setValues(data);
 357                     me.isValid(); // trigger validation
 358                 }
 359             });
 360         }
 361     }
 362 });