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' && !me.isCreate) {
  27             iface_vtype = 'InterfaceName';
  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         var column2 = [];
  44
  45         if (!(me.iftype === 'OVSIntPort' || me.iftype === 'OVSPort' ||
  46               me.iftype === 'OVSBond')) {
  47             column2.push({
  48                 xtype: 'proxmoxcheckbox',
  49                 fieldLabel: gettext('Autostart'),
  50                 name: 'autostart',
  51                 uncheckedValue: 0,
  52                 checked: me.isCreate ? true : undefined
  53             });
  54         }
  55
  56         if (me.iftype === 'bridge') {
  57             column2.push({
  58                 xtype: 'proxmoxcheckbox',
  59                 fieldLabel: gettext('VLAN aware'),
  60                 name: 'bridge_vlan_aware',
  61                 deleteEmpty: !me.isCreate
  62             });
  63             column2.push({
  64                 xtype: 'textfield',
  65                 fieldLabel: gettext('Bridge ports'),
  66                 name: 'bridge_ports'
  67             });
  68         } else if (me.iftype === 'OVSBridge') {
  69             column2.push({
  70                 xtype: 'textfield',
  71                 fieldLabel: gettext('Bridge ports'),
  72                 name: 'ovs_ports'
  73             });
  74             column2.push({
  75                 xtype: 'textfield',
  76                 fieldLabel: gettext('OVS options'),
  77                 name: 'ovs_options'
  78             });
  79         } else if (me.iftype === 'OVSPort' || me.iftype === 'OVSIntPort') {
  80             column2.push({
  81                 xtype: me.isCreate ? 'PVE.form.BridgeSelector' : 'displayfield',
  82                 fieldLabel: Proxmox.Utils.render_network_iface_type('OVSBridge'),
  83                 allowBlank: false,
  84                 nodename: me.nodename,
  85                 bridgeType: 'OVSBridge',
  86                 name: 'ovs_bridge'
  87             });
  88             column2.push({
  89                 xtype: 'pveVlanField',
  90                 deleteEmpty: !me.isCreate,
  91                 name: 'ovs_tag',
  92                 value: ''
  93             });
  94             column2.push({
  95                 xtype: 'textfield',
  96                 fieldLabel: gettext('OVS options'),
  97                 name: 'ovs_options'
  98             });
  99         } else if (me.iftype === 'bond') {
 100             column2.push({
 101                 xtype: 'textfield',
 102                 fieldLabel: gettext('Slaves'),
 103                 name: 'slaves'
 104             });
 105
 106             var policySelector = Ext.createWidget('bondPolicySelector', {
 107                 fieldLabel: gettext('Hash policy'),
 108                 name: 'bond_xmit_hash_policy',
 109                 deleteEmpty: !me.isCreate,
 110                 disabled: true
 111             });
 112
 113             var primaryfield = Ext.createWidget('textfield', {
 114                 fieldLabel: gettext('bond-primary'),
 115                 name: 'bond-primary',
 116                 value: '',
 117                 disabled: true
 118             });
 119
 120             column2.push({
 121                 xtype: 'bondModeSelector',
 122                 fieldLabel: gettext('Mode'),
 123                 name: 'bond_mode',
 124                 value: me.isCreate ? 'balance-rr' : undefined,
 125                 listeners: {
 126                     change: function(f, value) {
 127                         if (value === 'balance-xor' ||
 128                             value === '802.3ad') {
 129                             policySelector.setDisabled(false);
 130                             primaryfield.setDisabled(true);
 131                             primaryfield.setValue('');
 132                         } else if (value === 'active-backup') {
 133                             primaryfield.setDisabled(false);
 134                             policySelector.setDisabled(true);
 135                             policySelector.setValue('');
 136                         } else {
 137                             policySelector.setDisabled(true);
 138                             policySelector.setValue('');
 139                             primaryfield.setDisabled(true);
 140                             primaryfield.setValue('');
 141                         }
 142                     }
 143                 },
 144                 allowBlank: false
 145             });
 146
 147             column2.push(policySelector);
 148             column2.push(primaryfield);
 149
 150         } else if (me.iftype === 'OVSBond') {
 151             column2.push({
 152                 xtype: me.isCreate ? 'PVE.form.BridgeSelector' : 'displayfield',
 153                 fieldLabel: Proxmox.Utils.render_network_iface_type('OVSBridge'),
 154                 allowBlank: false,
 155                 nodename: me.nodename,
 156                 bridgeType: 'OVSBridge',
 157                 name: 'ovs_bridge'
 158             });
 159             column2.push({
 160                 xtype: 'pveVlanField',
 161                 deleteEmpty: !me.isCreate,
 162                 name: 'ovs_tag',
 163                 value: ''
 164             });
 165             column2.push({
 166                 xtype: 'textfield',
 167                 fieldLabel: gettext('OVS options'),
 168                 name: 'ovs_options'
 169             });
 170         }
 171
 172         column2.push({
 173             xtype: 'textfield',
 174             fieldLabel: gettext('Comment'),
 175             allowBlank: true,
 176             nodename: me.nodename,
 177             name: 'comments'
 178         });
 179
 180         var url;
 181         var method;
 182
 183         if (me.isCreate) {
 184             url = "/api2/extjs/nodes/" + me.nodename + "/network";
 185             method = 'POST';
 186         } else {
 187             url = "/api2/extjs/nodes/" + me.nodename + "/network/" + me.iface;
 188             method = 'PUT';
 189         }
 190
 191         var column1 = [
 192             {
 193                 xtype: 'hiddenfield',
 194                 name: 'type',
 195                 value: me.iftype
 196             },
 197             {
 198                 xtype: me.isCreate ? 'textfield' : 'displayfield',
 199                 fieldLabel: gettext('Name'),
 200                 name: 'iface',
 201                 value: me.iface,
 202                 vtype: iface_vtype,
 203                 allowBlank: false
 204             }
 205         ];
 206
 207         if (me.iftype === 'OVSBond') {
 208             column1.push(
 209                 {
 210                     xtype: 'bondModeSelector',
 211                     fieldLabel: gettext('Mode'),
 212                     name: 'bond_mode',
 213                     openvswitch: true,
 214                     value: me.isCreate ? 'active-backup' : undefined,
 215                     allowBlank: false
 216                 },
 217                 {
 218                     xtype: 'textfield',
 219                     fieldLabel: gettext('Slaves'),
 220                     name: 'ovs_bonds'
 221                 }
 222             );
 223         } else {
 224
 225             column1.push(
 226                 {
 227                     xtype: 'proxmoxtextfield',
 228                     deleteEmpty: !me.isCreate,
 229                     fieldLabel: 'IPv4/CIDR',
 230                     vtype: 'IPCIDRAddress',
 231                     name: 'cidr'
 232                 },
 233                 {
 234                     xtype: 'proxmoxtextfield',
 235                     deleteEmpty: !me.isCreate,
 236                     fieldLabel: gettext('Gateway') + ' (IPv4)',
 237                     vtype: 'IPAddress',
 238                     name: 'gateway'
 239                 },
 240                 {
 241                     xtype: 'proxmoxtextfield',
 242                     deleteEmpty: !me.isCreate,
 243                     fieldLabel: 'IPv6/CIDR',
 244                     vtype: 'IP6CIDRAddress',
 245                     name: 'cidr6'
 246                 },
 247                 {
 248                     xtype: 'proxmoxtextfield',
 249                     deleteEmpty: !me.isCreate,
 250                     fieldLabel: gettext('Gateway') + ' (IPv6)',
 251                     vtype: 'IP6Address',
 252                     name: 'gateway6'
 253                 },
 254                 {
 255                     xtype: 'proxmoxintegerfield',
 256                     minValue: 1280,
 257                     maxValue: 65520,
 258                     deleteEmpty: !me.isCreate,
 259                     fieldLabel: 'MTU',
 260                     name: 'mtu'
 261                 }
 262             );
 263         }
 264
 265         Ext.applyIf(me, {
 266             url: url,
 267             method: method,
 268             items: {
 269                 xtype: 'inputpanel',
 270                 column1: column1,
 271                 column2: column2
 272             }
 273         });
 274
 275         me.callParent();
 276
 277         if (me.isCreate) {
 278             me.down('field[name=iface]').setValue(me.iface_default);
 279         } else {
 280             me.load({
 281                 success: function(response, options) {
 282                     var data = response.result.data;
 283                     if (data.type !== me.iftype) {
 284                         var msg = "Got unexpected device type";
 285                         Ext.Msg.alert(gettext('Error'), msg, function() {
 286                             me.close();
 287                         });
 288                         return;
 289                     }
 290                     me.setValues(data);
 291                     me.isValid(); // trigger validation
 292                 }
 293             });
 294         }
 295     }
 296 });