ifstate 1.13.7__py3-none-any.whl → 2.0.0__py3-none-any.whl

libifstate/parser/base.py

@@ -1,12 +1,26 @@
+from libifstate.hook import HOOK_DIR
 from libifstate.util import logger
 from libifstate.exception import ParserValidationError
 from abc import ABC, abstractmethod
 from copy import deepcopy
+import os
+
+
+def get_available_hooks():
+    # check if there is a hooks dir before trying to scan it
+    if not os.path.isdir(HOOK_DIR):
+        return {}
+
+    hooks = {}
+    with os.scandir(HOOK_DIR) as it:
+        for dentry in it:
+            if dentry.is_file():
+                hooks[dentry.name] = {}
+    return hooks
 
 
 class Parser(ABC):
     _default_lo_link = {
-        'name': 'lo',
         'addresses': [
             '127.0.0.1/8',
             '::1/128',
@@ -18,79 +32,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},
+                ],
             }
         }
     }
@@ -113,12 +144,12 @@ class Parser(ABC):
         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])
+        if 'interfaces' in cfg and isinstance(cfg['interfaces'], dict):
+            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 +157,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'")
 
@@ -135,19 +166,34 @@ class Parser(ABC):
         for namespace in cfg.get('namespaces', {}):
             self._update_lo(cfg['namespaces'][namespace])
 
+        # add available hooks
+        if "hooks"  in cfg["parameters"]:
+            hooks = get_available_hooks()
+            hooks.update(cfg["parameters"]["hooks"])
+            cfg["parameters"]["hooks"] = hooks
+        else:
+            cfg["parameters"]["hooks"] = get_available_hooks()
+
         # 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
 

libifstate/routing/__init__.py

@@ -1,6 +1,6 @@
 from libifstate.util import logger, IfStateLogging
 from libifstate.exception import RouteDuplicate, netlinkerror_classes
-from ipaddress import ip_address, ip_network, IPv6Network
+from ipaddress import ip_address, ip_interface, ip_network, IPv6Network
 from pyroute2.netlink.rtnl.fibmsg import FR_ACT_VALUES
 from pyroute2.netlink.rtnl import rt_type
 import collections.abc
@@ -202,7 +202,7 @@ class RTLookup():
         self.str2id = {}
         self.id2str = {}
 
-        for basedir in ['/usr/share/iproute2', '/usr/lib/iproute2', '/etc/iproute2']:
+        for basedir in ['/usr/share/iproute2', '/etc/iproute2']:
             fn = os.path.join(basedir, name)
             try:
                 with open(fn, 'r') as fp:
@@ -284,8 +284,8 @@ class Tables(collections.abc.Mapping):
                     idx = next(
                         iter(self.netns.ipr.link_lookup(ifname=ignore[attr])), None)
                     if idx is None:
-                        logger.debug("{} '{}' is unknown".format(attr, ignore[attr]))
-                        del ignore[attr]
+                        logger.debug("{} '{}' is unknown, skipping ignore".format(attr, ignore[attr]))
+                        continue
                     else:
                         ignore[attr] = idx
             parsed.append(ignore)
@@ -321,7 +321,7 @@ class Tables(collections.abc.Mapping):
                 continue
 
             if route['dst_len'] > 0:
-                dst = ip_network(
+                dst = ip_interface(
                     '{}/{}'.format(route.get_attr('RTA_DST'), route['dst_len'])).with_prefixlen
             elif route['family'] == AF_INET:
                 dst = ip_network('0.0.0.0/0').with_prefixlen
@@ -546,13 +546,18 @@ class Rules():
                 'tos': rule['tos'],
             }
 
-            if rule['dst_len'] > 0:
-                ru['dst'] = rule.get_attr('FRA_DST')
-                ru['dst_len'] = rule['dst_len']
+            # add source and destination ip spaces even if they are not given by pyroute2
+            # as the user might specify something like "from: ::/0" explicitly which would not
+            # be present on a krule (because default values are ommited by pyroute2) and therefore
+            # would not match, even though it is the same rule
+            # if the user doesn't specify 'from' or 'to', these fields are just ignored because
+            # rule_matches is instructed to only check fields that are present on the config rule,
+            # meaning that these just get ignored
+            ru['dst'] = rule.get_attr('FRA_DST', default=("::" if rule['family'] == AF_INET6 else "0.0.0.0"))
+            ru['dst_len'] = rule['dst_len']
 
-            if rule['src_len'] > 0:
-                ru['src'] = rule.get_attr('FRA_SRC')
-                ru['src_len'] = rule['src_len']
+            ru['src'] = rule.get_attr('FRA_SRC', default=("::" if rule['family'] == AF_INET6 else "0.0.0.0"))
+            ru['src_len'] = rule['src_len']
 
             for field in ['iifname', 'oifname', 'fwmark', 'ip_proto']:
                 value = rule.get_attr('FRA_{}'.format(field.upper()))
@@ -593,7 +598,7 @@ class Rules():
                 del rule['protocol']
 
             if 'src_len' in rule and rule['src_len'] > 0:
-                rule['from'] = ip_network(
+                rule['from'] = ip_interface(
                     '{}/{}'.format(rule['src'], rule['src_len'])).with_prefixlen
 
             for key in ['src', 'src_len', 'tos', 'protocol']:
@@ -609,32 +614,51 @@ class Rules():
 
         # get rules that are currently in the kernels list
         krules = self.kernel_rules()
+
+        # loop over all rules that are wanted by the config
         for rule in self.rules:
             log_str = '#{}'.format(rule['priority'])
+
+            if rule.get('family', None) == AF_INET6:
+                log_str += " (inet6)"
+            elif rule.get('family', None) == AF_INET:
+                log_str += " (inet)"
+
             if self.netns.netns != None:
                 log_str += "[netns={}]".format(self.netns.netns)
 
+            vrrp_matched = vrrp_match(rule, by_vrrp, vrrp_type, vrrp_name, vrrp_state)
+            # 'found' indicates whether the rule wanted by the config was found
+            # in the kernels rules. if not, it is going to be added below
             found = False
-            matched = vrrp_match(rule, by_vrrp, vrrp_type, vrrp_name, vrrp_state)
             for i, krule in enumerate(krules):
                 if rule_matches(
                     rule,
                     krule,
                     # skip helper attrs like _vrrp
+                    # note that rule_matches it told to only check fields that are
+                    # present on the config rule, so additional ones from the krule
+                    # just get ignored
                     [key for key in rule.keys() if key[0] != '_']
                 ):
                     found = True
 
-                    # remove kernel routes due to vrrp_match
-                    if matched != VRRP_MATCH_DISABLE:
+                    # we've just confirmed that this krule matches a rule
+                    # that is wanted by the config so we delete it from the
+                    # krules because any that remain in krule are unwanted
+                    # and get deleted below
+                    # EXCEPT if vrrp tells us to leave it be
+                    if vrrp_matched != VRRP_MATCH_DISABLE:
                         del krules[i]
 
                     break
 
-            if matched not in [VRRP_MATCH_IGNORE, VRRP_MATCH_DISABLE]:
+            if vrrp_matched not in [VRRP_MATCH_IGNORE, VRRP_MATCH_DISABLE]:
                 if found:
+                    # rule already exists
                     logger.log_ok(log_str)
                 else:
+                    # rule doesn't exist, add it
                     logger.log_add(log_str)
 
                     logger.debug("ip rule add: {}".format(
@@ -647,7 +671,12 @@ class Rules():
                             raise
                         logger.warning('rule setup failed: {}'.format(err.args[1]))
 
+        # at this point all wanted rules have been deleted from the krules list,
+        # leaving the rest to be deleted here (see 'del krules[i]' above)
         for rule in krules:
+
+            # if this rule falls into the ignored ones (like the ones set by the kernel itself by default)
+            # we will ignore it and continue
             ignore = False
             for irule in ignores:
                 if 'proto' in irule:
@@ -659,9 +688,26 @@ class Rules():
             if ignore:
                 continue
 
-            logger.log_del('#{}'.format(rule['priority']))
+            log_str = '#{}'.format(rule['priority'])
+
+            if rule.get('family', None) == AF_INET6:
+                log_str += " (inet6)"
+            elif rule.get('family', None) == AF_INET:
+                log_str += " (inet)"
+
+            logger.log_del(log_str)
+
             try:
                 if do_apply:
+                    # for some reason pyroute2 raises an exception when
+                    # we pass an address like "0.0.0.0" or "::" with an
+                    # 'src_len' or 'dst_len' of 0.
+                    # using this as a workaround:
+                    if rule['src_len'] == 0:
+                        del rule['src']
+                    if rule['dst_len'] == 0:
+                        del rule['dst']
+
                     self.netns.ipr.rule('del', **rule)
             except Exception as err:
                 if not isinstance(err, netlinkerror_classes):