ifstate 1.13.6__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

libifstate/link/base.py

@@ -1,4 +1,4 @@
-from libifstate.util import logger, IfStateLogging, LinkDependency
+from libifstate.util import logger, format_ether_address, IfStateLogging, LinkDependency, IDENTIFY_LOOKUPS
 from libifstate.exception import ExceptionCollector, LinkTypeUnknown, NetnsUnknown, netlinkerror_classes
 from libifstate.brport import BRPort
 from libifstate.routing import RTLookups
@@ -129,7 +129,7 @@ class Link(ABC):
         return super().__new__(GenericLink)
         #raise LinkTypeUnknown()
 
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
         self.ifstate = ifstate
         self.netns = netns
         self.cap_create = True
@@ -139,6 +139,7 @@ class Link(ABC):
         }
         self.settings.update(link)
         self.ethtool = None
+        self.hooks = hooks
         self.vrrp = vrrp
         if brport:
             self.brport = BRPort(netns, name, brport)
@@ -154,22 +155,17 @@ class Link(ABC):
         self.link_ref = LinkDependency(name, self.netns.netns)
 
         # prepare link registry search filters
-        if 'businfo' in self.settings:
-            self.settings['businfo'] = self.settings['businfo'].lower()
-            self.link_registry_search_args.append({
-                'kind': self.settings['kind'],
-                'businfo': self.settings['businfo'],
-            })
-
-        if 'permaddr' in self.settings:
-            self.settings['permaddr'] = self.settings['permaddr'].lower()
-            self.link_registry_search_args.append({
-                'kind': self.settings['kind'],
-                'permaddr': self.settings['permaddr'],
-            })
+        if identify:
+            search_args = {}
+            for attr in IDENTIFY_LOOKUPS.keys():
+                if attr in identify:
+                    search_args[attr] = identify[attr]
+            if search_args:
+                search_args['kind'] = self.settings['kind']
+                self.link_registry_search_args.append(search_args)
 
         if 'address' in self.settings and self.settings['kind'] == 'physical':
-            self.settings['address'] = self.settings['address'].lower()
+            self.settings['address'] = format_ether_address(self.settings['address'])
             self.link_registry_search_args.append({
                 'kind': self.settings['kind'],
                 'address': self.settings['address'],
@@ -249,11 +245,8 @@ class Link(ABC):
             return None
 
     def get_if_attr(self, key):
-        if key in ["state", "permaddr", "businfo"]:
-            if key in self.iface:
-                return self.iface[key]
-            else:
-                return None
+        if key == "state":
+            return self.iface.get(key)
 
         if key in self.attr_map:
             return self._drill_attr(self.iface, self.attr_map[key])
@@ -452,11 +445,17 @@ class Link(ABC):
                 netns_attr = "{}_netns".format(attr)
                 netnsid_attr = "{}_netnsid".format(attr)
                 if netns_attr in self.settings:
-                    # ToDo: throw exception for unknown netns
-                    (peer_ipr, peer_nsid) = self.netns.get_netnsid(self.settings[netns_attr])
-                    self.settings[netnsid_attr] = peer_nsid
-                    idx = next(iter(peer_ipr.link_lookup(
-                        ifname=self.settings[attr])), None)
+                    # ignore *_netns settings if the netns is the same as the interface's one
+                    # (there is no IFLA_LINK_NETNSID attribute in such cases)
+                    if self.settings[netns_attr] != self.netns.netns:
+                        # ToDo: throw exception for unknown netns
+                        (peer_ipr, peer_nsid) = self.netns.get_netnsid(self.settings[netns_attr])
+                        self.settings[netnsid_attr] = peer_nsid
+                        idx = next(iter(peer_ipr.link_lookup(
+                            ifname=self.settings[attr])), None)
+                    else:
+                        idx = next(iter(self.netns.ipr.link_lookup(
+                            ifname=self.settings[attr])), None)
 
                     del(self.settings[netns_attr])
                 else:
@@ -516,13 +515,6 @@ class Link(ABC):
         if self.idx is not None:
             self.iface = item.netns.ipr.get_link(self.idx)
         if self.idx is not None and self.iface is not None:
-            permaddr = item.netns.ipr.get_permaddr(self.iface.get_attr('IFLA_IFNAME'))
-            if not permaddr is None:
-                self.iface['permaddr'] = permaddr
-            businfo = item.netns.ipr.get_businfo(self.iface.get_attr('IFLA_IFNAME'))
-            if not businfo is None:
-                self.iface['businfo'] = businfo
-
             # check for ifname collisions
             idx = next(iter(self.netns.ipr.link_lookup(
                 ifname=self.settings['ifname'])), None)
@@ -625,6 +617,9 @@ class Link(ABC):
                                 if not isinstance(err, netlinkerror_classes):
                                     raise
                                 excpts.add('set', err, state=state)
+
+                    # get kernel state
+                    self.iface = self.netns.ipr.get_link(self.idx)
             except Exception as err:
                 if not isinstance(err, netlinkerror_classes):
                     raise
@@ -737,7 +732,7 @@ class Link(ABC):
             if do_apply:
                 # temp. remove special settings
                 skipped_settings = {}
-                for setting in ['state', 'peer', 'kind', 'businfo', 'permaddr']:
+                for setting in ['state', 'peer', 'kind']:
                     if setting in self.settings:
                         skipped_settings[setting] = self.settings.pop(setting)
 
@@ -832,6 +827,9 @@ class Link(ABC):
             else:
                 logger.log_ok('link')
 
+            # update kernel state
+            self.iface = self.netns.ipr.get_link(self.idx)
+
     def depends(self):
         deps = []
 
@@ -894,5 +892,5 @@ class Link(ABC):
 
 
 class GenericLink(Link):
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
-        super().__init__(ifstate, netns, name, link, ethtool, vrrp, brport)
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
+        super().__init__(ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport)

libifstate/link/physical.py

@@ -3,8 +3,8 @@ from libifstate.link.base import Link
 from libifstate.exception import LinkCannotAdd
 
 class PhysicalLink(Link):
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
-        super().__init__(ifstate, netns, name, link, ethtool, vrrp, brport)
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
+        super().__init__(ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport)
         self.cap_create = False
         self.cap_ethtool = True
         self.ethtool = ethtool

libifstate/link/tun.py

@@ -6,14 +6,14 @@ from pwd import getpwnam
 from grp import getgrnam
 
 class TunLink(Link):
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
         if 'tun_owner' in link and isinstance(link['tun_owner'], str):
             link['tun_owner'] = getpwnam(link['tun_owner'])[2]
 
         if 'tun_group' in link and isinstance(link['tun_group'], str):
             link['tun_group'] = getgrnam(link['tun_group'])[2]
 
-        super().__init__(ifstate, netns, name, link, ethtool, vrrp, brport)
+        super().__init__(ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport)
         self.cap_create = bool(link.get('tun_persist'))
  
     def create(self, do_apply, sysctl, excpts, oper="add"):

libifstate/link/veth.py

@@ -3,14 +3,14 @@ from libifstate.link.base import Link
 from libifstate.exception import LinkCannotAdd, NetnsUnknown
 
 class VethLink(Link):
-    def __init__(self, ifstate, netns, name, link, ethtool, vrrp, brport):
+    def __init__(self, ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport):
         # use the bind_netns implementation to create the peer in the
         # target netns
         if 'peer_netns' in link:
             link['bind_netns'] = link['peer_netns']
             del(link['peer_netns'])
 
-        super().__init__(ifstate, netns, name, link, ethtool, vrrp, brport)
+        super().__init__(ifstate, netns, name, link, identify, ethtool, hooks, vrrp, brport)
 
     def create(self, do_apply, sysctl, excpts, oper="add"):
         '''

libifstate/netns/__init__.py

@@ -1,10 +1,11 @@
-from libifstate.util import logger, IfStateLogging, IPRouteExt, NetNSExt, root_ipr
+from libifstate.util import logger, IfStateLogging, IPRouteExt, NetNSExt, root_ipr, root_iw, IDENTIFY_LOOKUPS
 from libifstate.sysctl import Sysctl
 
 import atexit
 from copy import deepcopy
 import logging
 import pyroute2
+from pyroute2.netlink.exceptions import NetlinkError
 import re
 import secrets
 import shutil
@@ -13,6 +14,7 @@ import subprocess
 netns_name_map = {}
 netns_name_root = None
 netns_nsid_map = {}
+iw_ifindex_phy_map = {}
 
 @atexit.register
 def close_netns():
@@ -44,12 +46,27 @@ class NetNameSpace():
 
         if name is None:
             self.ipr = root_ipr
+            self.iw = root_iw
             self.mount = b''
         else:
             self.ipr = NetNSExt(name)
             netns_name_map[name] = self.ipr
+
+            # check for wireless phys
+            if root_iw:
+                pyroute2.netns.pushns(name)
+                self.iw = pyroute2.IW()
+                pyroute2.netns.popns()
+            else:
+                self.iw = None
+
             self.mount = name.encode("utf-8")
 
+        if self.iw is not None:
+            for ifname, ifdict in self.iw.get_interfaces_dict().items():
+                # ifIndex => phyIndex
+                iw_ifindex_phy_map[ifdict[0]] = ifdict[3]
+
     def __deepcopy__(self, memo):
         '''
         Add custom deepcopy implementation to keep single IPRoute and NetNS instances.
@@ -59,7 +76,10 @@ class NetNameSpace():
         memo[id(self)] = result
         for k, v in self.__dict__.items():
             if k == 'ipr':
-                setattr(result, k, v)
+                if self.netns is None:
+                    setattr(result, k, IPRouteExt())
+                else:
+                    setattr(result, k, NetNSExt(self.netns))
             else:
                 setattr(result, k, deepcopy(v, memo))
         return result
@@ -81,7 +101,7 @@ class NetNameSpace():
 
         return (peer_ipr, peer_nsid)
 
-def prepare_netns(do_apply, target_netns_list, new_netns_list):
+def prepare_netns(do_apply, target_netns_list, new_netns_list, ignore_netns):
     logger.info("configure network namespaces...")
 
     # get mapping of netns names to lists of pids
@@ -94,14 +114,15 @@ def prepare_netns(do_apply, target_netns_list, new_netns_list):
     for name in sorted(names_set):
         # cleanup orphan netns
         if name not in target_netns_list:
-            if name in ns_pids:
-                logger.warning(
-                    'pids: {}'.format(', '.join((str(x) for x in ns_pids[name]))),
-                    extra={'iface': name})
-            logger.log_del(name)
+            if not any(re.match(regex, name) for regex in ignore_netns):
+                if name in ns_pids:
+                    logger.warning(
+                        'pids: {}'.format(', '.join((str(x) for x in ns_pids[name]))),
+                        extra={'iface': name})
+                logger.log_del(name)
 
-            if do_apply:
-                pyroute2.netns.remove(name)
+                if do_apply:
+                    pyroute2.netns.remove(name)
 
         # create missing netns
         elif name not in current_netns_list or name in new_netns_list:
@@ -222,8 +243,16 @@ class LinkRegistryItem():
             self.attributes['kind'] = linkinfo.get_attr('IFLA_INFO_KIND')
         else:
             self.attributes['kind'] = "physical"
-            self.attributes['businfo'] = self.netns.ipr.get_businfo(self.attributes['ifname'])
-            self.attributes['permaddr'] = link.get_attr('IFLA_PERM_ADDRESS')
+
+        # add iw phy for wireless interfaces
+        if link['index'] in iw_ifindex_phy_map:
+            self.attributes['wiphy'] = iw_ifindex_phy_map[link['index']]
+
+        # add identify attributes
+        for attr, lookup in IDENTIFY_LOOKUPS.items():
+            value = lookup(netns, link)
+            if value is not None:
+                self.attributes[attr] = value
 
     def __ipr_link(self, command, **kwargs):
         logger.debug("ip link set netns={} {}".format(
@@ -270,7 +299,14 @@ class LinkRegistryItem():
             # ToDo
             self.update_ifname( self.registry.get_random_name('__netns__') )
 
-        self.__ipr_link('set', index=self.attributes['index'], net_ns_fd=netns_name)
+        if self.attributes.get('wiphy') is not None:
+            # move phy instead of iface for wireless devices
+            if netns.netns is None:
+                self.netns.iw.set_wiphy_netns_by_pid(self.attributes['wiphy'], 1)
+            else:
+                self.netns.iw.set_wiphy_netns_by_pid(self.attributes['wiphy'], netns.ipr.child)
+        else:
+            self.__ipr_link('set', index=self.attributes['index'], net_ns_fd=netns_name)
         self.netns = netns
         self.attributes['index'] = next(iter(self.netns.ipr.link_lookup(ifname=self.attributes['ifname'])), None)
 

libifstate/parser/base.py

@@ -6,7 +6,6 @@ from copy import deepcopy
 
 class Parser(ABC):
     _default_lo_link = {
-        'name': 'lo',
         'addresses': [
             '127.0.0.1/8',
             '::1/128',
@@ -18,79 +17,96 @@ class Parser(ABC):
         }
     }
     _default_ifstates = {
-        'ignore': {
-            'ipaddr_builtin': [
-                'fe80::/10'
-            ],
-            'ipaddr_dynamic': True,
-            'ifname_builtin': [
-                r'^br-[\da-f]{12}',
-                r'^docker\d+',
-                r'^ppp\d+$',
-                r'^veth',
-                r'^virbr\d+',
-                r'^vrrp\d*\.\d+$'
-            ],
-            'fdb_builtin': [
-                r'^33:33:',
-                r'^01:00:5e:'
-            ],
-            'routes_builtin': [
-                {'proto': 1},
-                {'proto': 2},
-                {'proto': 8},
-                {'proto': 9},
-                {'proto': 10},
-                {'proto': 11},
-                {'proto': 12},
-                {'proto': 13},
-                {'proto': 14},
-                {'proto': 15},
-                {'proto': 16},
-                {'proto': 18},
-                {'proto': 42},
-                {'proto': 186},
-                {'proto': 187},
-                {'proto': 188},
-                {'proto': 189},
-                {'proto': 192},
-                {'to': 'ff00::/8'},
-            ],
-            'rules_builtin': [
-                {'proto': 1},
-                {'proto': 2},
-                {'proto': 8},
-                {'proto': 9},
-                {'proto': 10},
-                {'proto': 11},
-                {'proto': 12},
-                {'proto': 13},
-                {'proto': 14},
-                {'proto': 15},
-                {'proto': 16},
-                {'proto': 18},
-                {'proto': 42},
-                {'proto': 186},
-                {'proto': 187},
-                {'proto': 188},
-                {'proto': 189},
-                {'proto': 192},
-            ],
-        },
-        'cshaper': {
-            'default': {
-                'egress_qdisc': {
-                    'kind': 'cake',
-                    'handle': '1:',
-                },
-                'ingress_qdisc': {
-                    'kind': 'cake',
-                    'handle': '1:',
-                },
-                'ingress_ifname': {
-                    'search': r'^\D{1,3}',
-                    'replace': 'ifb',
+        'parameters': {
+            'cshaper': {
+                'default': {
+                    'egress_qdisc': {
+                        'kind': 'cake',
+                        'handle': '1:',
+                    },
+                    'ingress_qdisc': {
+                        'kind': 'cake',
+                        'handle': '1:',
+                    },
+                    'ingress_ifname': {
+                        'search': r'^\D{1,3}',
+                        'replace': 'ifb',
+                    }
+                }
+            },
+            'defaults_builtin': [
+                {
+                    'match': [
+                        {'ifname': ''}
+                    ],
+                    'clear_addresses': True,
+                    'clear_fdb': True,
+                    'clear_neighbours': True,
+                    'clear_tc': True,
+                    'link': {
+                        'state': 'down',
+                        'master': None
+                    }
                 }
+            ],
+            'ignore': {
+                'ipaddr_builtin': [
+                    'fe80::/10'
+                ],
+                'ipaddr_dynamic': True,
+                'ifname_builtin': [
+                    r'^br-[\da-f]{12}',
+                    r'^docker\d+',
+                    r'^ppp\d+$',
+                    r'^veth',
+                    r'^virbr\d+',
+                    r'^vrrp\d*\.\d+$'
+                ],
+                'fdb_builtin': [
+                    r'^33:33:',
+                    r'^01:00:5e:'
+                ],
+                'routes_builtin': [
+                    {'proto': 1},
+                    {'proto': 2},
+                    {'proto': 8},
+                    {'proto': 9},
+                    {'proto': 10},
+                    {'proto': 11},
+                    {'proto': 12},
+                    {'proto': 13},
+                    {'proto': 14},
+                    {'proto': 15},
+                    {'proto': 16},
+                    {'proto': 18},
+                    {'proto': 42},
+                    {'proto': 186},
+                    {'proto': 187},
+                    {'proto': 188},
+                    {'proto': 189},
+                    {'proto': 192},
+                    {'to': 'ff00::/8'},
+                ],
+                'rules_builtin': [
+                    {'proto': 1},
+                    {'proto': 2},
+                    {'proto': 8},
+                    {'proto': 9},
+                    {'proto': 10},
+                    {'proto': 11},
+                    {'proto': 12},
+                    {'proto': 13},
+                    {'proto': 14},
+                    {'proto': 15},
+                    {'proto': 16},
+                    {'proto': 18},
+                    {'proto': 42},
+                    {'proto': 186},
+                    {'proto': 187},
+                    {'proto': 188},
+                    {'proto': 189},
+                    {'proto': 192},
+                ],
             }
         }
     }
@@ -114,11 +130,11 @@ class Parser(ABC):
 
     def _update_lo(self, cfg):
         if 'interfaces' in cfg:
-            lo = next((idx for idx, iface in enumerate(cfg['interfaces']) if iface['name'] == 'lo'), None)
-            if lo is not None:
-                cfg['interfaces'][lo] = self.merge(deepcopy(Parser._default_lo_link), cfg['interfaces'][lo])
+            if 'lo' in cfg['interfaces']:
+                cfg['interfaces']['lo'] = self.merge(
+                    deepcopy(Parser._default_lo_link), cfg['interfaces']['lo'])
             else:
-                cfg['interfaces'].append(Parser._default_lo_link)
+                cfg['interfaces']['lo'] = Parser._default_lo_link
 
     def config(self):
         # merge builtin defaults with config
@@ -126,7 +142,7 @@ class Parser(ABC):
 
         # 'ignore' should still be an object
         try:
-            iter(cfg["ignore"])
+            iter(cfg["parameters"]["ignore"])
         except TypeError:
             raise ParserValidationError("$.ignore: is not of type 'object'")
 
@@ -136,18 +152,25 @@ class Parser(ABC):
             self._update_lo(cfg['namespaces'][namespace])
 
         # merge builtin defaults
-        for k in list(cfg["ignore"]):
+        if "defaults" in cfg["parameters"]:
+            cfg["parameters"]["defaults"].extend(cfg["parameters"]["defaults_builtin"])
+        else:
+            cfg["parameters"]["defaults"] = cfg["parameters"]["defaults_builtin"]
+        del cfg["parameters"]["defaults_builtin"]
+
+        # merge builtin ignore lists
+        for k in list(cfg["parameters"]["ignore"]):
             if k.endswith("_builtin"):
                 n = k[:-8]
-                if n in cfg["ignore"]:
+                if n in cfg["parameters"]["ignore"]:
                     try:
-                        cfg["ignore"][n] += cfg["ignore"][k]
+                        cfg["parameters"]["ignore"][n] += cfg["parameters"]["ignore"][k]
                     except TypeError:
                         raise ParserValidationError("$.ignore.{}: is not of type '{}'".format(
-                            n, type(cfg["ignore"][k]).__name__))
+                            n, type(cfg["parameters"]["ignore"][k]).__name__))
                 else:
-                    cfg["ignore"][n] = cfg["ignore"][k]
-                del(cfg["ignore"][k])
+                    cfg["parameters"]["ignore"][n] = cfg["parameters"]["ignore"][k]
+                del (cfg["parameters"]["ignore"][k])
 
         return cfg