mirror of
https://github.com/CumulusNetworks/ifupdown2.git
synced 2024-05-06 15:54:50 +00:00
9f30b2cca7
Ticket: CM-6908, CM-6110, CM-13221
Reviewed By: julien, nikhil
Testing Done: added a new test in ifupdown2-tests which covers all cases
- move all mtu handling to a single function in addons/address.py
- Have an ifupdown2 default of 1500 mtu
- add a policy manager max_mtu check (we want to default cumulus max mtu
to 9216)
- special handling for bond and bridges
- print an info log abt setting mtu on bridge
- this can be enhanced in the future to look
at individual port mtu and rejecting the bridge mtu.
this operation can be expensive right now. Hence
just an info log.
- bond and vxlan dev mtu follow the rules of physical device mtu
Signed-off-by: Roopa Prabhu <roopa@cumulusnetworks.com>
243 lines
9.5 KiB
Python
243 lines
9.5 KiB
Python
#!/usr/bin/python
|
|
#
|
|
# Copyright 2014 Cumulus Networks, Inc. All rights reserved.
|
|
# Author: Roopa Prabhu, roopa@cumulusnetworks.com
|
|
#
|
|
|
|
from ifupdown.iface import *
|
|
from ifupdownaddons.modulebase import moduleBase
|
|
from ifupdownaddons.iproute2 import iproute2
|
|
import ifupdown.ifupdownconfig as ifupdownConfig
|
|
|
|
from ifupdown.netlink import netlink
|
|
import ifupdown.ifupdownflags as ifupdownflags
|
|
import logging
|
|
import re
|
|
|
|
class vlan(moduleBase):
|
|
""" ifupdown2 addon module to configure vlans """
|
|
|
|
_modinfo = {'mhelp' : 'vlan module configures vlan interfaces.' +
|
|
'This module understands vlan interfaces with dot ' +
|
|
'notations. eg swp1.100. Vlan interfaces with any ' +
|
|
'other names need to have raw device and vlan id ' +
|
|
'attributes',
|
|
'attrs' : {
|
|
'vlan-raw-device' :
|
|
{'help' : 'vlan raw device',
|
|
'validvals': ['<interface>']},
|
|
'vlan-id' :
|
|
{'help' : 'vlan id',
|
|
'validrange' : ['0', '4096']}}}
|
|
|
|
|
|
def __init__(self, *args, **kargs):
|
|
moduleBase.__init__(self, *args, **kargs)
|
|
self.ipcmd = None
|
|
self._bridge_vids_query_cache = {}
|
|
self._resv_vlan_range = self._get_reserved_vlan_range()
|
|
self.logger.debug('%s: using reserved vlan range %s'
|
|
%(self.__class__.__name__, str(self._resv_vlan_range)))
|
|
|
|
def _is_vlan_device(self, ifaceobj):
|
|
vlan_raw_device = ifaceobj.get_attr_value_first('vlan-raw-device')
|
|
if vlan_raw_device:
|
|
return True
|
|
elif '.' in ifaceobj.name:
|
|
return True
|
|
return False
|
|
|
|
def _get_vlan_id(self, ifaceobj):
|
|
""" Derives vlanid from iface name
|
|
|
|
Example:
|
|
Returns 1 for ifname vlan0001 returns 1
|
|
Returns 1 for ifname vlan1
|
|
Returns 1 for ifname eth0.1
|
|
|
|
Returns -1 if vlan id cannot be determined
|
|
"""
|
|
vid_str = ifaceobj.get_attr_value_first('vlan-id')
|
|
try:
|
|
if vid_str: return int(vid_str)
|
|
except:
|
|
return -1
|
|
|
|
if '.' in ifaceobj.name:
|
|
vid_str = ifaceobj.name.split('.', 1)[1]
|
|
elif ifaceobj.name.startswith('vlan'):
|
|
vid_str = ifaceobj.name[4:]
|
|
else:
|
|
return -1
|
|
try:
|
|
vid = int(vid_str)
|
|
except:
|
|
return -1
|
|
return vid
|
|
|
|
def _is_vlan_by_name(self, ifacename):
|
|
return '.' in ifacename
|
|
|
|
def _get_vlan_raw_device_from_ifacename(self, ifacename):
|
|
""" Returns vlan raw device from ifname
|
|
Example:
|
|
Returns eth0 for ifname eth0.100
|
|
|
|
Returns None if vlan raw device name cannot
|
|
be determined
|
|
"""
|
|
vlist = ifacename.split('.', 1)
|
|
if len(vlist) == 2:
|
|
return vlist[0]
|
|
return None
|
|
|
|
def _get_vlan_raw_device(self, ifaceobj):
|
|
vlan_raw_device = ifaceobj.get_attr_value_first('vlan-raw-device')
|
|
if vlan_raw_device:
|
|
return vlan_raw_device
|
|
return self._get_vlan_raw_device_from_ifacename(ifaceobj.name)
|
|
|
|
def get_dependent_ifacenames(self, ifaceobj, ifaceobjs_all=None):
|
|
if not self._is_vlan_device(ifaceobj):
|
|
return None
|
|
ifaceobj.link_kind |= ifaceLinkKind.VLAN
|
|
return [self._get_vlan_raw_device(ifaceobj)]
|
|
|
|
def _bridge_vid_add_del(self, ifaceobj, bridgename, vlanid,
|
|
add=True):
|
|
""" If the lower device is a vlan aware bridge, add/del the vlanid
|
|
to the bridge """
|
|
if self.ipcmd.bridge_is_vlan_aware(bridgename):
|
|
if add:
|
|
netlink.link_add_bridge_vlan(bridgename, vlanid)
|
|
else:
|
|
netlink.link_del_bridge_vlan(bridgename, vlanid)
|
|
|
|
def _bridge_vid_check(self, ifaceobj, ifaceobjcurr, bridgename, vlanid):
|
|
""" If the lower device is a vlan aware bridge, check if the vlanid
|
|
is configured on the bridge """
|
|
if not self.ipcmd.bridge_is_vlan_aware(bridgename):
|
|
return
|
|
vids = self._bridge_vids_query_cache.get(bridgename)
|
|
if vids == None:
|
|
vids = self.ipcmd.bridge_port_vids_get(bridgename)
|
|
self._bridge_vids_query_cache[bridgename] = vids
|
|
if not vids or vlanid not in vids:
|
|
ifaceobjcurr.status = ifaceStatus.ERROR
|
|
ifaceobjcurr.status_str = 'bridge vid error'
|
|
|
|
def _up(self, ifaceobj):
|
|
vlanid = self._get_vlan_id(ifaceobj)
|
|
if vlanid == -1:
|
|
raise Exception('could not determine vlanid')
|
|
vlanrawdevice = self._get_vlan_raw_device(ifaceobj)
|
|
if not vlanrawdevice:
|
|
raise Exception('could not determine vlan raw device')
|
|
if not ifupdownflags.flags.PERFMODE:
|
|
if not self.ipcmd.link_exists(vlanrawdevice):
|
|
raise Exception('rawdevice %s not present' %vlanrawdevice)
|
|
if self.ipcmd.link_exists(ifaceobj.name):
|
|
self._bridge_vid_add_del(ifaceobj, vlanrawdevice, vlanid)
|
|
return
|
|
netlink.link_add_vlan(vlanrawdevice, ifaceobj.name, vlanid)
|
|
self._bridge_vid_add_del(ifaceobj, vlanrawdevice, vlanid)
|
|
if ifaceobj.addr_method == 'manual':
|
|
try:
|
|
netlink.link_set_updown(ifaceobj.name, "up")
|
|
except Exception as e:
|
|
self.log_error('%s: %s' % (ifaceobj.name, str(e)), ifaceobj)
|
|
|
|
def _down(self, ifaceobj):
|
|
vlanid = self._get_vlan_id(ifaceobj)
|
|
if vlanid == -1:
|
|
raise Exception('could not determine vlanid')
|
|
vlanrawdevice = self._get_vlan_raw_device(ifaceobj)
|
|
if not vlanrawdevice:
|
|
raise Exception('could not determine vlan raw device')
|
|
if (not ifupdownflags.flags.PERFMODE and
|
|
not self.ipcmd.link_exists(ifaceobj.name)):
|
|
return
|
|
try:
|
|
self.ipcmd.link_delete(ifaceobj.name)
|
|
self._bridge_vid_add_del(ifaceobj, vlanrawdevice, vlanid, add=False)
|
|
except Exception, e:
|
|
self.log_warn(str(e))
|
|
|
|
def _query_check(self, ifaceobj, ifaceobjcurr):
|
|
if not self.ipcmd.link_exists(ifaceobj.name):
|
|
return
|
|
if not '.' in ifaceobj.name:
|
|
# if vlan name is not in the dot format, check its running state
|
|
(vlanrawdev, vlanid) = self.ipcmd.get_vlandev_attrs(ifaceobj.name)
|
|
if vlanrawdev != ifaceobj.get_attr_value_first('vlan-raw-device'):
|
|
ifaceobjcurr.update_config_with_status('vlan-raw-device',
|
|
vlanrawdev, 1)
|
|
else:
|
|
ifaceobjcurr.update_config_with_status('vlan-raw-device',
|
|
vlanrawdev, 0)
|
|
vlanid_config = ifaceobj.get_attr_value_first('vlan-id')
|
|
if not vlanid_config:
|
|
vlanid_config = str(self._get_vlan_id(ifaceobj))
|
|
if vlanid != vlanid_config:
|
|
ifaceobjcurr.update_config_with_status('vlan-id', vlanid, 1)
|
|
else:
|
|
ifaceobjcurr.update_config_with_status('vlan-id', vlanid, 0)
|
|
self._bridge_vid_check(ifaceobj, ifaceobjcurr, vlanrawdev, vlanid)
|
|
|
|
def _query_running(self, ifaceobjrunning):
|
|
if not self.ipcmd.link_exists(ifaceobjrunning.name):
|
|
return
|
|
(vlanrawdev, vlanid) = self.ipcmd.get_vlandev_attrs(ifaceobjrunning.name)
|
|
if not vlanid:
|
|
return
|
|
# If vlan name is not in the dot format, get the
|
|
# vlan dev and vlan id
|
|
if not '.' in ifaceobjrunning.name:
|
|
ifaceobjrunning.update_config_dict({(k, v) for k, v in
|
|
{'vlan-raw-device' : vlanrawdev,
|
|
'vlan-id' : vlanid}.items()
|
|
if v})
|
|
|
|
_run_ops = {'pre-up' : _up,
|
|
'post-down' : _down,
|
|
'query-checkcurr' : _query_check,
|
|
'query-running' : _query_running}
|
|
|
|
def get_ops(self):
|
|
""" returns list of ops supported by this module """
|
|
return self._run_ops.keys()
|
|
|
|
def _init_command_handlers(self):
|
|
if not self.ipcmd:
|
|
self.ipcmd = iproute2()
|
|
|
|
def run(self, ifaceobj, operation, query_ifaceobj=None, **extra_args):
|
|
""" run vlan configuration on the interface object passed as argument
|
|
|
|
Args:
|
|
**ifaceobj** (object): iface object
|
|
|
|
**operation** (str): any of 'pre-up', 'post-down', 'query-checkcurr',
|
|
'query-running'
|
|
Kwargs:
|
|
**query_ifaceobj** (object): query check ifaceobject. This is only
|
|
valid when op is 'query-checkcurr'. It is an object same as
|
|
ifaceobj, but contains running attribute values and its config
|
|
status. The modules can use it to return queried running state
|
|
of interfaces. status is success if the running state is same
|
|
as user required state in ifaceobj. error otherwise.
|
|
"""
|
|
if ifaceobj.type == ifaceType.BRIDGE_VLAN:
|
|
return
|
|
op_handler = self._run_ops.get(operation)
|
|
if not op_handler:
|
|
return
|
|
if (operation != 'query-running' and
|
|
not self._is_vlan_device(ifaceobj)):
|
|
return
|
|
self._init_command_handlers()
|
|
if operation == 'query-checkcurr':
|
|
op_handler(self, ifaceobj, query_ifaceobj)
|
|
else:
|
|
op_handler(self, ifaceobj)
|