ifstate 1.9.0__py3-none-any.whl → 1.10.1__py3-none-any.whl

libifstate/netns/__init__.py

@@ -6,10 +6,16 @@ import logging
 import pyroute2
 import re
 import secrets
+import shutil
+import subprocess
 
 netns_name_map = {}
 netns_name_root = None
 netns_nsid_map = {}
+findmnt_cmd = shutil.which('findmnt')
+
+if findmnt_cmd is None:
+    logger.debug("findmnt binary is not available, netns binding of links might not be correct")
 
 @atexit.register
 def close_netns():
@@ -25,6 +31,7 @@ class NetNameSpace():
         self.links = {}
         self.addresses = {}
         self.bpf_progs = None
+        self.fdb = {}
         self.neighbours = {}
         self.vrrp = {
             'links': [],
@@ -40,9 +47,14 @@ class NetNameSpace():
 
         if name is None:
             self.ipr = root_ipr
+            self.mount = b''
         else:
             self.ipr = NetNSExt(name)
             netns_name_map[name] = self.ipr
+            if findmnt_cmd is None:
+                self.mount = name.encode("utf-8")
+            else:
+                self.mount = subprocess.check_output([findmnt_cmd, '-f', '-J', "/run/netns/{}".format(name)])
 
     def get_netnsid(self, peer_netns_name):
         if peer_netns_name is None:
@@ -51,17 +63,17 @@ class NetNameSpace():
         else:
             peer_ipr = netns_name_map[peer_netns_name]
             peer_pid = peer_ipr.child
-    
+
         result = self.ipr.get_netnsid(pid=peer_pid)
         if result['nsid'] == 4294967295:
             self.ipr.set_netnsid(pid=peer_pid)
             result = self.ipr.get_netnsid(pid=peer_pid)
-    
+
         peer_nsid = result['nsid']
 
         return (peer_ipr, peer_nsid)
 
-def prepare_netns(do_apply, target_netns_list):
+def prepare_netns(do_apply, target_netns_list, new_netns_list):
     logger.info("configure network namespaces...")
 
     # get mapping of netns names to lists of pids
@@ -84,7 +96,7 @@ def prepare_netns(do_apply, target_netns_list):
                 pyroute2.netns.remove(name)
 
         # create missing netns
-        elif name not in current_netns_list:
+        elif name not in current_netns_list or name in new_netns_list:
             logger.log_add(name)
 
         # log already existing namespaces
@@ -123,25 +135,33 @@ class LinkRegistry():
         self.ignores = ignores
 
         for namespace in namespaces:
-            self._inventory_netns(namespace)
+            self.inventory_netns(namespace)
 
         if logger.getEffectiveLevel() <= logging.DEBUG:
             self.debug_dump()
 
+    def add_link(self, netns, link):
+        item = LinkRegistryItem(
+            self,
+            netns,
+            link,
+        )
+        self.registry.append(item)
+        return item
+
     def get_link(self, **attributes):
         for link in self.registry:
             if link.match(**attributes):
                 return link
         return None
 
-    def _inventory_netns(self, target_netns):
+    def inventory_netns(self, target_netns):
         for link in target_netns.ipr.get_links():
-            if link['index'] > 1:
-                self.registry.append(LinkRegistryItem(
-                    self,
-                    target_netns,
-                    link,
-                ))
+            self.registry.append(LinkRegistryItem(
+                self,
+                target_netns,
+                link,
+            ))
 
     def get_random_name(self, prefix):
         hex_length = int((15-len(prefix))/2)
@@ -209,7 +229,8 @@ class LinkRegistryItem():
 
         idx = next(iter(netns.ipr.link_lookup(ifname=self.attributes['ifname'])), None)
         if idx is not None:
-            self.update_name( self.link_registry.get_random_name('__netns__') )
+            # ToDo
+            self.update_ifname( self.link_registry.get_random_name('__netns__') )
 
         self.__ipr_link('set', index=self.attributes['index'], net_ns_fd=netns_name)
         self.netns = netns

libifstate/parser/base.py

@@ -5,6 +5,18 @@ from copy import deepcopy
 
 
 class Parser(ABC):
+    _default_lo_link = {
+        'name': 'lo',
+        'addresses': [
+            '127.0.0.1/8',
+            '::1/128',
+        ],
+        'link': {
+            'kind': 'physical',
+            'state': 'up',
+            'mtu': 65536,
+        }
+    }
     _default_ifstates = {
         'ignore': {
             'ipaddr_builtin': [
@@ -14,12 +26,15 @@ class Parser(ABC):
             'ifname_builtin': [
                 r'^br-[\da-f]{12}',
                 r'^docker\d+',
-                r'^lo$',
                 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},
@@ -97,6 +112,14 @@ class Parser(ABC):
                     a[key] = b[key]
         return a
 
+    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])
+            else:
+                cfg['interfaces'].append(Parser._default_lo_link)
+
     def config(self):
         # merge builtin defaults with config
         cfg = (self.merge(deepcopy(Parser._default_ifstates), self.ifstates))
@@ -107,6 +130,11 @@ class Parser(ABC):
         except TypeError:
             raise ParserValidationError("$.ignore: is not of type 'object'")
 
+        # add loopback interface defaults
+        self._update_lo(cfg)
+        for namespace in cfg.get('namespaces', {}):
+            self._update_lo(cfg['namespaces'][namespace])
+
         # merge builtin defaults
         for k in list(cfg["ignore"]):
             if k.endswith("_builtin"):

libifstate/sysctl/__init__.py

@@ -7,11 +7,15 @@ import os
 class Sysctl():
     def __init__(self, netns):
         self.sysctls = {}
+        self.globals = {}
         self.netns = netns
 
     def add(self, iface, sysctl):
         self.sysctls[iface] = sysctl
 
+    def add_global(self, proto, sysctl):
+        self.globals[proto] = sysctl
+
     def set_sysctl(self, iface_current, iface_config, family, key, val, do_apply):
         if self.netns.netns is not None:
             pyroute2.netns.pushns(self.netns.netns)
@@ -66,3 +70,14 @@ class Sysctl():
 
     def has_settings(self, iface):
         return iface in self.sysctls
+
+    def apply_globals(self, do_apply):
+        changes = []
+        for proto, sysctl in self.globals.items():
+            for key, val in sysctl.items():
+                if self.set_sysctl('..', '..', proto, key, val, do_apply):
+                    changes.append(proto)
+        return changes
+
+    def has_globals(self):
+        return len(self.globals) > 0

libifstate/util.py

@@ -2,7 +2,8 @@ from libifstate.log import logger, IfStateLogging
 from pyroute2 import IPRoute, NetNS, netns
 
 from pyroute2.netlink.rtnl.tcmsg import tcmsg
-from pyroute2.netlink.rtnl import RTM_DELTFILTER
+from pyroute2.netlink.rtnl import RTM_DELTFILTER, RTM_NEWNSID
+from pyroute2.netlink.rtnl.nsidmsg import nsidmsg
 from pyroute2.netlink import NLM_F_REQUEST
 from pyroute2.netlink import NLM_F_ACK
 from pyroute2.netlink import NLM_F_CREATE
@@ -132,13 +133,36 @@ class IPRouteExt(IPRoute):
         return None
 
     def get_ifname_by_index(self, index):
-        link = next(iter(ipr.get_links(index)), None)
+        link = next(iter(self.get_links(index)), None)
 
         if link is None:
             return index
 
         return link.get_attr('IFLA_IFNAME')
 
+    def set_netnsid(self, nsid=None, pid=None, fd=None):
+        '''
+        call pyroute2's set_netnsid if available or use
+        fallback implementation for pyroute2 <=0.79
+        '''
+        if hasattr(super(), 'set_netnsid'):
+            return super().set_netnsid(nsid, pid, fd)
+        else:
+            msg = nsidmsg()
+
+            if nsid is None or nsid < 0:
+                # kernel auto select
+                msg['attrs'].append(('NETNSA_NSID', 4294967295))
+            else:
+                msg['attrs'].append(('NETNSA_NSID', nsid))
+
+            if pid is not None:
+                msg['attrs'].append(('NETNSA_PID', pid))
+
+            if fd is not None:
+                msg['attrs'].append(('NETNSA_FD', fd))
+
+            return self.nlm_request(msg, RTM_NEWNSID, NLM_F_REQUEST | NLM_F_ACK)
 
 class NetNSExt(NetNS):
     def __init__(self, *args, **kwargs):
@@ -220,13 +244,37 @@ class NetNSExt(NetNS):
         return None
 
     def get_ifname_by_index(self, index):
-        link = next(iter(ipr.get_links(index)), None)
+        link = next(iter(self.get_links(index)), None)
 
         if link is None:
             return index
 
         return link.get_attr('IFLA_IFNAME')
 
+    def set_netnsid(self, nsid=None, pid=None, fd=None):
+        '''
+        call pyroute2's set_netnsid if available or use
+        fallback implementation for pyroute2 <=0.79
+        '''
+        if hasattr(super(), 'set_netnsid'):
+            return super().set_netnsid(nsid, pid, fd)
+        else:
+            msg = nsidmsg()
+
+            if nsid is None or nsid < 0:
+                # kernel auto select
+                msg['attrs'].append(('NETNSA_NSID', 4294967295))
+            else:
+                msg['attrs'].append(('NETNSA_NSID', nsid))
+
+            if pid is not None:
+                msg['attrs'].append(('NETNSA_PID', pid))
+
+            if fd is not None:
+                msg['attrs'].append(('NETNSA_FD', fd))
+
+            return self.nlm_request(msg, RTM_NEWNSID, NLM_F_REQUEST | NLM_F_ACK)
+
 class LinkDependency:
     def __init__(self, ifname, netns):
         self.ifname = ifname
@@ -240,14 +288,23 @@ class LinkDependency:
 
     def __lt__(self, obj):
         if self.netns is None:
-            return True
-
-        if obj.netns is None:
+            if obj.netns is not None:
+                return True
+        elif obj.netns is None:
             return False
 
         if self.netns != obj.netns:
             return self.netns < obj.netns
 
+        if self.ifname == obj.ifname:
+            return False
+
+        if self.ifname == 'lo':
+            return True
+
+        if obj.ifname == 'lo':
+            return False
+
         return self.ifname < obj.ifname
 
     def __ne__(self, other):