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

ifstate/ifstate.py

@@ -21,6 +21,7 @@ import yaml
 class Actions():
     CHECK = "check"
     APPLY = "apply"
+    IDENTIFY = "identify"
     SHOW = "show"
     SHOWALL = "showall"
     VRRP = "vrrp"
@@ -31,6 +32,7 @@ class Actions():
 ACTIONS_HELP = {
     "CHECK"      : "dry run update the network config",
     "APPLY"      : "update the network config",
+    "IDENTIFY"   : "show interface attributes available for identification",
     "SHOW"       : "show running network config",
     "SHOWALL"    : "show running network config (more settings)",
     "VRRP"       : "run as keepalived notify script",
@@ -128,14 +130,16 @@ def main():
     group = parser.add_mutually_exclusive_group()
     parser.add_argument('--version', action='version',
                         version='%(prog)s {version}'.format(version=__version__))
-    group.add_argument("-v", "--verbose", action="store_true",
-                       help="be more verbose")
+    group.add_argument("-v", "--verbose", action="count", default=0,
+                       help="be more verbose (twice for very verbose)")
     group.add_argument("-q", "--quiet", action="store_true",
                        help="be more quiet, print only warnings and errors")
     parser.add_argument("-s", "--soft-schema", action="store_true",
                         help="ignore schema validation errors, expect ifstatecli to trigger internal exceptions")
+    parser.add_argument("-S", "--show-secrets", action="store_true",
+                        help="show secrets when dumping config")
     parser.add_argument("-c", "--config", type=str,
-                        default="/etc/ifstate/config.yml", help="configuration YaML filename")
+                        default="/etc/ifstate/ifstate.yaml", help="configuration YaML filename")
     subparsers = parser.add_subparsers(
         dest='action', required=True, help="specifies the action to perform")
 
@@ -162,10 +166,10 @@ def main():
         "name", type=str, help="name of the vrrp group or instance")
 
     args = parser.parse_args()
-    if args.verbose:
+    if args.verbose > 0:
         lvl = logging.DEBUG
     elif args.quiet:
-        lvl = logging.ERROR
+        lvl = logging.WARNING
     else:
         lvl = logging.INFO
 
@@ -178,15 +182,18 @@ def main():
         shell()
         exit(0)
 
-    ifslog = IfStateLogging(lvl, action=args.action)
+    ifslog = IfStateLogging(lvl, args.verbose > 1, action=args.action)
 
-    if args.action in [Actions.SHOW, Actions.SHOWALL]:
+    if args.action in [Actions.IDENTIFY, Actions.SHOW, Actions.SHOWALL]:
         # preserve dict order on python 3.7+
         if sys.version_info >= (3, 7):
             yaml.add_representer(
                 dict, lambda self, data: yaml.representer.SafeRepresenter.represent_dict(self, data.items()))
         ifs = IfState()
-        print(yaml.dump(ifs.show(args.action == Actions.SHOWALL)))
+        if args.action == Actions.IDENTIFY:
+            print(yaml.dump(ifs.identify()))
+        else:
+            print(yaml.dump(ifs.show(args.action == Actions.SHOWALL, args.show_secrets)))
 
         ifslog.quit()
         exit(0)

ifstate/vrrp.py

@@ -139,7 +139,7 @@ def vrrp_fifo(args_fifo, ifs_config):
 
     try:
         status_pattern = re.compile(
-            r'(group|instance) "([^"]+)" (' + '|'.join(KEEPALIVED_STATES) + ')( \d+)?$', re.IGNORECASE)
+            r'(group|instance) "([^"]+)" (' + '|'.join(KEEPALIVED_STATES) + r')( \d+)?$', re.IGNORECASE)
 
         with open(args_fifo) as fifo:
             logger.debug("entering fifo loop...")

{ifstate-1.13.6.dist-info → ifstate-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ifstate
-Version: 1.13.6
+Version: 2.0.0
 Summary: Manage host interface settings in a declarative manner
 Home-page: https://ifstate.net/
 Author: Thomas Liske
@@ -9,7 +9,7 @@ License: GPL3+
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jsonschema
-Requires-Dist: pyroute2
+Requires-Dist: pyroute2!=0.9.3
 Requires-Dist: pyyaml
 Requires-Dist: setproctitle
 Provides-Extra: shell

ifstate-2.0.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+ifstate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ifstate/ifstate.py,sha256=Vot_Bo0MGT_5MUKD5-pt2xB-fLLkjwvJo24KgtETtR8,9329
+ifstate/shell.py,sha256=7_JFpi4icr9MijynDzbb0v5mxhFsng6PCC4m3uQ255A,2177
+ifstate/vrrp.py,sha256=FJ9b1eJseTtZFfknHU-xV68Qz7cPrRrc5PTcjUVj-fY,5953
+ifstate-2.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+libifstate/__init__.py,sha256=HFLB_cWQSAUarRzPCDdTFuL5EB1WjV1Fn0q_ut0RVvo,34053
+libifstate/exception.py,sha256=NmKqD9O8dRWBgO__Pt0_wGSR5GWZ1RHXZZEUI3ArVLo,2360
+libifstate/log.py,sha256=rG0ISWyeGGlC_jRREoSpkdySc5EmyhOQIgSfvRqlaZA,4651
+libifstate/util.py,sha256=DqYyFzNqRceJxxGqTg94gT8OTHQQ2gZxQOo5Gzx6-6s,11555
+libifstate/address/__init__.py,sha256=SobrZ9e2ItrmEidnKPBhUMitRDdTEajbkU9Rkmtx-gQ,3165
+libifstate/bpf/__init__.py,sha256=NVzaunTmJU2PbIQg9eWBMKpFgLh3EnD3ujNa7Yt6rNc,7699
+libifstate/bpf/ctypes.py,sha256=kLZJHZlba09Vc-tbsJAcKpDwdoNO2IjlYVLCopawHmA,4274
+libifstate/bpf/map.py,sha256=cLHNMvRBDNW2yVCEf3z242_oRdU0HqVbFEYVkKXng0w,10818
+libifstate/brport/__init__.py,sha256=NzdA8F4hr2se1bXKNnyKZbvOFlCWBq_cdjwsL1H0Y-o,2964
+libifstate/fdb/__init__.py,sha256=9dpL5n8ct3CaA-z8I6ZEkD3yL6yWJQeq3fpIe9pc2zw,6486
+libifstate/hook/__init__.py,sha256=012SIm1aULlXG4SoOYFV46u9k-4pPgtIENaUlRWPpe8,7375
+libifstate/hook/wrapper.sh,sha256=ipCmvcadJbXTT6oUR7BIhT5uglITnHfiAdm44vydZuw,1101
+libifstate/link/__init__.py,sha256=epVw6jY8exNeJZUmmUas91yJoeupfgIY7rthq7SGIIw,142
+libifstate/link/base.py,sha256=zsitL1kSPLvjzZqyUIyEoCVlE_dhX2z5acNL1iZ2EAE,34508
+libifstate/link/dsa.py,sha256=zOdatHE9_TLVVqP2H87V3d_M6Y3fRke2FqHj0u_Su2c,260
+libifstate/link/physical.py,sha256=IG1OXG2q25QmvhxEDhyT-bf7guwIyXl0OzSJgQOqXzY,613
+libifstate/link/tun.py,sha256=Rzn3ysE0cVuQGi3naxs9QXYBrLwVQTaVrFv2dtR1D60,1012
+libifstate/link/veth.py,sha256=Sv5WZMMsefYFz9I0BQSZyKytCQYxv0vjwAnB7FYHR1A,2283
+libifstate/neighbour/__init__.py,sha256=FJJpbJvqnxvOEii6QDMYzW5jQDEbiEy71GQOEbqaS48,2463
+libifstate/netns/__init__.py,sha256=5Ak4vHU5UvdSYPFIQ8i8VMba2luyUeSpYAtRXxdTGPE,10287
+libifstate/parser/__init__.py,sha256=uzv5U-6RPy-SSIyxR6H_F0SvAOQQF8x5ygErpUhsa7Y,109
+libifstate/parser/base.py,sha256=v0S_R_aMZBdHJPI3zdelv5G0Xha-pUV2DRdmxhD7390,6624
+libifstate/parser/yaml.py,sha256=MC0kmwqt3P45z61fb_wfUqoj0iZyhFYkdPyr0UqMSZA,1415
+libifstate/routing/__init__.py,sha256=O4lbaCJvLgx-iQUa0WDgRmSPR4AKvveqPgxxb4HwYQ4,25305
+libifstate/schema/2/ifstate.conf.schema.json,sha256=hVf0fduVV09uw3ZphWWwGpeQ7nL5z1aLTHUEemn34wc,221185
+libifstate/sysctl/__init__.py,sha256=_QNmH0CirbBy8VAupTm6UhIhB88fGWqUy9TnfmS0j5I,3637
+libifstate/tc/__init__.py,sha256=T8LEBxiHZH4sayPn9lK5hK8eB8dskuw6-kw81W_aMWU,12097
+libifstate/wireguard/__init__.py,sha256=VSn3PzQXwZeRV1qf5nOc_RbeePQlXu8FUh2Lg356-ZA,8869
+libifstate/xdp/__init__.py,sha256=X1xhEIGng7R5d5F4KsChykT2g6H-XBRWbWABijoYDQA,7208
+ifstate-2.0.0.dist-info/METADATA,sha256=f8JoMVgocYw7ow9r6dny6Hrpk1UQRUkrjEN0ASmYkwE,1604
+ifstate-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ifstate-2.0.0.dist-info/entry_points.txt,sha256=HF6jX7Uu_nF1Ly-J9uEPeiRapOxnM6LuHsb2y6Mt-k4,52
+ifstate-2.0.0.dist-info/top_level.txt,sha256=A7peI7aKBaM69fsiSPvMbL3rzTKZZr5qDxKC-pHMGdE,19
+ifstate-2.0.0.dist-info/RECORD,,

{ifstate-1.13.6.dist-info → ifstate-2.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

libifstate/__init__.py

@@ -2,9 +2,10 @@ from libifstate.exception import LinkDuplicate, NetnsUnknown
 from libifstate.link.base import ethtool_path, Link
 from libifstate.address import Addresses
 from libifstate.fdb import FDB
+from libifstate.hook import Hooks
 from libifstate.neighbour import Neighbours
 from libifstate.routing import Tables, Rules, RTLookups
-from libifstate.parser import Parser
+from libifstate.parser import Parser, get_available_hooks
 from libifstate.tc import TC
 from libifstate.exception import netlinkerror_classes
 import bisect
@@ -34,11 +35,16 @@ except ModuleNotFoundError:
     # ignore missing plugin
     pass
 
+try:
+    from jsonschema import validate, ValidationError, FormatChecker
+except ModuleNotFoundError:
+    # fail open and ignore missing jsonschema dependency
+    pass
+
 from libifstate.netns import NetNameSpace, prepare_netns, LinkRegistry, get_netns_instances
-from libifstate.util import logger, IfStateLogging, LinkDependency
+from libifstate.util import logger, root_iw, kind_has_identify, IfStateLogging, LinkDependency, IDENTIFY_LOOKUPS
 from libifstate.exception import FeatureMissingError, LinkCircularLinked, LinkNoConfigFound, ParserValidationError
 from ipaddress import ip_network, ip_interface
-from jsonschema import validate, ValidationError, FormatChecker
 from copy import deepcopy
 import os
 import pkgutil
@@ -48,8 +54,7 @@ import json
 import errno
 import logging
 
-__version__ = "1.13.6"
-
+__version__ = "2.0.0"
 
 class IfState():
     def __init__(self):
@@ -61,9 +66,12 @@ class IfState():
         self.ignore = {}
         self.features = {
             'brport': True,
+            'devicetree': os.access('/sys/firmware/devicetree', os.R_OK),
+            'iw': root_iw is not None,
             'link': True,
             'sysctl': os.access('/proc/sys/net', os.R_OK),
             'ethtool': not ethtool_path is None,
+            'schema': not globals().get("validate") is None,
             'tc': True,
             'wireguard': not globals().get("WireGuard") is None,
             'bpf': not globals().get("libbpf") is None,
@@ -79,35 +87,38 @@ class IfState():
                 libbpf.libbpf_set_print(0)
 
     def update(self, ifstates, soft_schema):
-        # check config schema
-        schema = json.loads(pkgutil.get_data(
-            "libifstate", "../schema/ifstate.conf.schema.json"))
-        try:
-            validate(ifstates, schema, format_checker=FormatChecker())
-        except ValidationError as ex:
-            if len(ex.path) > 0:
-                path = ["$"]
-                for i, p in enumerate(ex.absolute_path):
-                    if type(p) == int:
-                        path.append("[{}]".format(p))
-                    else:
-                        path.append(".")
-                        path.append(p)
+        if self.features['schema']:
+            # check config schema
+            schema = json.loads(pkgutil.get_data(
+                "libifstate", "schema/{}/ifstate.conf.schema.json".format(__version__.split('.')[0])))
+            try:
+                validate(ifstates, schema, format_checker=FormatChecker())
+            except ValidationError as ex:
+                if len(ex.path) > 0:
+                    path = ["$"]
+                    for i, p in enumerate(ex.absolute_path):
+                        if type(p) == int:
+                            path.append("[{}]".format(p))
+                        else:
+                            path.append(".")
+                            path.append(p)
 
-                detail = "{}: {}".format("".join(path), ex.message)
-            else:
-                detail = ex.message
-            if soft_schema:
-                logger.error("Config validation failed for {}".format(detail))
-            else:
-                raise ParserValidationError(detail)
+                    detail = "{}: {}".format("".join(path), ex.message)
+                else:
+                    detail = ex.message
+                if soft_schema:
+                    logger.error("Config validation failed for {}".format(detail))
+                else:
+                    raise ParserValidationError(detail)
+        else:
+            logger.debug('Python package jsonschema not available, skipping config validation.')
 
         # add interface defaults
         if 'defaults' in ifstates:
-            self.defaults = ifstates['defaults']
+            self.defaults = ifstates['parameters']['defaults']
 
         # add ignore list items
-        self.ignore.update(ifstates['ignore'])
+        self.ignore.update(ifstates['parameters']['ignore'])
         self.ipaddr_ignore = set()
         for ip in self.ignore.get('ipaddr', []):
             self.ipaddr_ignore.add(ip_network(ip))
@@ -116,7 +127,10 @@ class IfState():
             self.fdb_ignore = re.compile('|'.join(self.ignore.get('fdb')))
 
         # save cshaper profiles
-        self.cshaper_profiles = ifstates['cshaper']
+        self.cshaper_profiles = ifstates['parameters']['cshaper']
+
+        # prepare hooks
+        self.hooks = Hooks(ifstates['parameters'].get('hooks', {}))
 
         # build link registry over all named netns
         self.link_registry = LinkRegistry(self.ignore.get('ifname', []), self.root_netns)
@@ -134,17 +148,15 @@ class IfState():
                 self._update(self.namespaces[netns_name], netns_ifstates)
 
     def _update(self, netns, ifstates):
-        # parse options
-        if 'options' in ifstates:
-            # parse global sysctl settings
-            if 'sysctl' in ifstates['options']:
-                for proto in  ifstates['options']['sysctl'].keys():
-                    if proto in ['all', 'default']:
-                        netns.sysctl.add(
-                            proto, ifstates['options']['sysctl'][proto])
-                    else:
-                        netns.sysctl.add_global(
-                            proto, ifstates['options']['sysctl'][proto])
+        # parse network sysctl settings
+        if 'sysctl' in ifstates:
+            for proto in  ifstates['sysctl'].keys():
+                if proto in ['all', 'default']:
+                    netns.sysctl.add(
+                        proto, ifstates['sysctl'][proto])
+                else:
+                    netns.sysctl.add_global(
+                        proto, ifstates['sysctl'][proto])
 
         # load BPF programs
         if 'bpf' in ifstates:
@@ -157,8 +169,7 @@ class IfState():
                 netns.bpf_progs.add(name, config)
 
         # add interfaces from config
-        for ifstate in ifstates['interfaces']:
-            name = ifstate['name']
+        for name, ifstate in ifstates['interfaces'].items():
             kind = ifstate['link']['kind']
             defaults = self.get_defaults(
                 ifname=name,
@@ -189,7 +200,7 @@ class IfState():
                 link.update(ifstate['link'])
             if link:
                 netns.links[name] = Link(self,
-                    netns, name, link, ethtool, ifstate.get('vrrp'), ifstate.get('brport'))
+                    netns, name, link, ifstate.get('identify', {}), ethtool, ifstate.get('hooks', []), ifstate.get('vrrp'), ifstate.get('brport'))
             else:
                 netns.links[name] = None
 
@@ -224,7 +235,7 @@ class IfState():
                 netns.sysctl.add(name, ifstate['sysctl'])
 
             if 'cshaper' in ifstate:
-                profile_name = ifstate['cshaper'].get(
+                profile_name = ifstate['parameters']['cshaper'].get(
                     'profile', 'default')
                 logger.debug('cshaper profile {} enabled'.format(profile_name),
                              extra={'iface': name, 'netns': netns})
@@ -246,7 +257,7 @@ class IfState():
                         'qdisc': cshaper_profile['ingress_qdisc'],
                     }
                 }
-                ifb_state['tc']['qdisc']['bandwidth'] = ifstate['cshaper'].get(
+                ifb_state['tc']['qdisc']['bandwidth'] = ifstate['parameters']['cshaper'].get(
                     'ingress', 'unlimited')
 
                 if 'vrrp' in ifstate:
@@ -279,10 +290,10 @@ class IfState():
                     ]
                 }
 
-                ifstate['tc']['qdisc']['bandwidth'] = ifstate['cshaper'].get(
+                ifstate['tc']['qdisc']['bandwidth'] = ifstate['parameters']['cshaper'].get(
                     'egress', 'unlimited')
 
-                del ifstate['cshaper']
+                del ifstate['parameters']['cshaper']
 
             if 'tc' in ifstate:
                 netns.tc[name] = TC(
@@ -347,8 +358,8 @@ class IfState():
                     # ignore if the link is already gone, this might happen
                     # when removing veth link peers
                     if err.code != errno.ENODEV:
-                        logger.warning('removing link {} failed: {}'.format(
-                            ifname, err.args[1]), extra={'netns': item.netns})
+                        logger.warning('removing failed: {}'.format(
+                            err.args[1]), extra={'iface': ifname, 'netns': item.netns})
             return True
         else:
             # shutdown physical interfaces
@@ -362,8 +373,8 @@ class IfState():
                     except Exception as err:
                         if not isinstance(err, netlinkerror_classes):
                             raise
-                        logger.warning('updating link {} failed: {}'.format(
-                            ifname, err.args[1]), extra={'netns': item.netns})
+                        logger.warning('updating failed: {}'.format(
+                            err.args[1]), extra={'iface': ifname, 'netns': item.netns})
             return False
 
     def _dependencies(self, netns):
@@ -455,7 +466,7 @@ class IfState():
 
         # create and destroy namespaces to match config
         if not by_vrrp and self.namespaces is not None:
-            prepare_netns(do_apply, self.namespaces.keys(), self.new_namespaces)
+            prepare_netns(do_apply, self.namespaces.keys(), self.new_namespaces, self.ignore.get('netns', []))
             logger.info("")
 
         # get link dependency tree
@@ -467,8 +478,10 @@ class IfState():
             cleanup_items = []
             for item in self.link_registry.registry:
                 ifname = item.attributes['ifname']
-                # items without a link are orphan - keep them if they match the ignore regex list...
-                if item.link is None and not any(re.match(regex, ifname) for regex in self.ignore.get('ifname', [])):
+                # items without a link are orphan - keep them if they match the ignore (ifname|netns) regex list...
+                if item.link is None and \
+                   not any(re.match(regex, ifname) for regex in self.ignore.get('ifname', [])) and \
+                   not any(re.match(regex, item.netns.netns or '') for regex in self.ignore.get('netns', [])):
                     # ...or are in a netns namespace while the config has no `namespaces` setting
                     if self.namespaces is not None or item.netns.netns is None:
                         if not had_cleanup:
@@ -514,9 +527,8 @@ class IfState():
                 if link_dep.netns is None:
                     self._apply_iface(do_apply, self.root_netns, link_dep, by_vrrp, vrrp_type, vrrp_name, vrrp_state)
                 else:
-                    if link_dep.netns not in self.namespaces:
-                        logger.warning("add link {} failed: netns '{}' is unknown".format(link_dep.ifname, link_dep.netns))
-                        return
+                    if self.namespaces is None or link_dep.netns not in self.namespaces:
+                        logger.warning("apply link {} failed: netns '{}' is unknown".format(link_dep.ifname, link_dep.netns))
                     else:
                         self._apply_iface(do_apply, self.namespaces[link_dep.netns], link_dep, by_vrrp, vrrp_type, vrrp_name, vrrp_state)
 
@@ -555,8 +567,10 @@ class IfState():
 
     def _apply_iface(self, do_apply, netns, link_dep, by_vrrp, vrrp_type, vrrp_name, vrrp_state):
         ifname = link_dep.ifname
-        if ifname in netns.links:
-            link = netns.links[ifname]
+        if not ifname in netns.links:
+            logger.warning('no link settings found', extra={'iface': ifname, 'netns': netns})
+            return
+        link = netns.links[ifname]
 
         # check for vrrp mode:
         #   disable: vrrp type & name matches, but vrrp state not
@@ -609,6 +623,8 @@ class IfState():
         if ifname in netns.wireguard:
             netns.wireguard[ifname].apply(do_apply)
 
+        self.hooks.apply(link, do_apply)
+
     def _apply_routing(self, do_apply, netns, by_vrrp, vrrp_type, vrrp_name, vrrp_state):
         if not netns.tables is None:
             netns.tables.apply(self.ignore.get('routes', []), do_apply, by_vrrp, vrrp_type, vrrp_name, vrrp_state)
@@ -616,36 +632,86 @@ class IfState():
         if not netns.rules is None:
             netns.rules.apply(self.ignore.get('rules', []), do_apply, by_vrrp, vrrp_type, vrrp_name, vrrp_state)
 
-    def show(self, showall=False):
+    def identify(self):
+        root_config = self._identify_netns(self.root_netns)
+        netns_instances = get_netns_instances()
+        if len(netns_instances) > 0:
+            netns_identifies = {}
+            for netns in netns_instances:
+                netns_identify = self._identify_netns(netns)
+                if netns_identify is not None:
+                    netns_identifies[netns.netns] = netns_identify
+
+            if netns_identifies:
+                return {**root_config, 'namespaces': netns_identifies}
+
+        return {**root_config}
+
+    def _identify_netns(self, netns):
+        ifs_links = {}
+        for ipr_link in netns.ipr.get_links():
+            name = ipr_link.get_attr('IFLA_IFNAME')
+            # skip links on ignore list
+            if name != 'lo' and not any(re.match(regex, name) for regex in Parser._default_ifstates['parameters']['ignore']['ifname_builtin']):
+                info = ipr_link.get_attr('IFLA_LINKINFO')
+                if info is None:
+                    kind = None
+                else:
+                    kind = info.get_attr('IFLA_INFO_KIND')
+
+                if not kind_has_identify(kind):
+                    continue
+
+                ifs_link = {
+                    'identify': {
+                    },
+                }
+
+                for attr, lookup in IDENTIFY_LOOKUPS.items():
+                    value = lookup(netns, ipr_link)
+                    if value is not None:
+                        ifs_link['identify'][attr] = value
+
+                ifs_links[name] = ifs_link
+
+        if ifs_links:
+            return {**{'interfaces': ifs_links}}
+        else:
+            return None
+
+    def show(self, showall=False, show_secrets=False):
         if showall:
             defaults = deepcopy(Parser._default_ifstates)
+
+            hooks = get_available_hooks()
+            if hooks:
+                defaults['parameters']['hooks'] = hooks
         else:
             defaults = {}
 
         ipaddr_ignore = []
-        for ip in Parser._default_ifstates['ignore']['ipaddr_builtin']:
+        for ip in Parser._default_ifstates['parameters']['ignore']['ipaddr_builtin']:
             ipaddr_ignore.append(ip_network(ip))
 
-        root_config = self._show_netns(self.root_netns, showall, ipaddr_ignore)
+        root_config = self._show_netns(self.root_netns, showall, show_secrets, ipaddr_ignore)
         netns_instances = get_netns_instances()
         if len(netns_instances) > 0:
             netns_configs = {}
             for netns in netns_instances:
-                netns_configs[netns.netns] = self._show_netns(netns, showall, ipaddr_ignore)
+                netns_configs[netns.netns] = self._show_netns(netns, showall, show_secrets, ipaddr_ignore)
 
             return {**defaults, **root_config, 'namespaces': netns_configs}
 
 
         return {**defaults, **root_config}
 
-    def _show_netns(self, netns, showall, ipaddr_ignore):
-        ifs_links = []
+    def _show_netns(self, netns, showall, show_secrets, ipaddr_ignore):
+        ifs_links = {}
         for ipr_link in netns.ipr.get_links():
             name = ipr_link.get_attr('IFLA_IFNAME')
             # skip links on ignore list
-            if name != 'lo' and not any(re.match(regex, name) for regex in Parser._default_ifstates['ignore']['ifname_builtin']):
+            if name != 'lo' and not any(re.match(regex, name) for regex in Parser._default_ifstates['parameters']['ignore']['ifname_builtin']):
                 ifs_link = {
-                    'name': name,
                     'addresses': [],
                     'link': {
                         'state': ipr_link['state'],
@@ -659,12 +725,16 @@ class IfState():
                         if not any(ip in net for net in ipaddr_ignore):
                             ifs_link['addresses'].append(ip.with_prefixlen)
 
+                # drop empty ip addresses list, they are cleaned up by default
+                if not ifs_link['addresses']:
+                    del(ifs_link['addresses'])
+
                 info = ipr_link.get_attr('IFLA_LINKINFO')
                 if info is None:
                     kind = None
                 else:
                     kind = info.get_attr('IFLA_INFO_KIND')
-                if kind is not None:
+                if not kind_has_identify(kind):
                     ifs_link['link']['kind'] = kind
 
                     data = info.get_attr('IFLA_INFO_DATA')
@@ -685,15 +755,13 @@ class IfState():
                     addr = ipr_link.get_attr('IFLA_ADDRESS')
                     if not addr is None:
                         ifs_link['link']['address'] = addr
-                    permaddr = netns.ipr.get_permaddr(name)
-                    if not permaddr is None:
-                        if addr is None:
-                            ifs_link['link']['addr'] = permaddr
-                        elif addr != permaddr:
-                            ifs_link['link']['permaddr'] = permaddr
-                    businfo = netns.ipr.get_businfo(name)
-                    if not businfo is None:
-                        ifs_link['link']['businfo'] = businfo
+
+                    # add identify section for physical links
+                    ifs_link['identify'] = {}
+                    for attr, func in IDENTIFY_LOOKUPS.items():
+                        value = func(netns, ipr_link)
+                        if value:
+                            ifs_link['identify'][attr] = value
 
                 # add device group if not 0
                 group = ipr_link.get_attr('IFLA_GROUP')
@@ -720,6 +788,9 @@ class IfState():
 
                 brport.BRPort.show(netns.ipr, showall, ipr_link['index'], ifs_link)
 
+                if ifs_link['link']['kind'] == 'wireguard':
+                    wireguard.WireGuard.show(netns, showall, show_secrets, name, ifs_link)
+
                 if name == 'lo':
                     if ifs_link['addresses'] == Parser._default_lo_link['addresses']:
                         del(ifs_link['addresses'])
@@ -728,13 +799,13 @@ class IfState():
                         del(ifs_link['link'])
 
                     if len(ifs_link) > 1:
-                        ifs_links.append(ifs_link)
+                        ifs_links['lo'] = ifs_link
                 else:
-                    ifs_links.append(ifs_link)
+                    ifs_links[name] = ifs_link
 
         routing = {
-            'routes': Tables(netns).show_routes(Parser._default_ifstates['ignore']['routes_builtin']),
-            'rules': Rules(netns).show_rules(Parser._default_ifstates['ignore']['rules_builtin']),
+            'routes': Tables(netns).show_routes(Parser._default_ifstates['parameters']['ignore']['routes_builtin']),
+            'rules': Rules(netns).show_rules(Parser._default_ifstates['parameters']['ignore']['rules_builtin']),
         }
 
         return {**{'interfaces': ifs_links, 'routing': routing}}

libifstate/address/__init__.py

@@ -18,8 +18,8 @@ class Addresses():
         # get ifindex
         idx = next(iter(self.netns.ipr.link_lookup(ifname=self.iface)), None)
 
+        # check if interface exists
         if idx == None:
-            logger.warning('link missing', extra={'iface': self.iface, 'netns': self.netns})
             return
 
         # get active ip addresses

libifstate/exception.py

@@ -1,19 +1,12 @@
-from pyroute2.netlink.exceptions import NetlinkError
+from pyroute2 import NetlinkError
 from libifstate.util import logger
 
-# pyroute2.minimal exceptions might be broken
-#   => workaround for pyroute2 #845 #847
 netlinkerror_classes = (NetlinkError)
-try:
-    from pr2modules.netlink.exceptions import NetlinkError as Pr2mNetlinkError
-    netlinkerror_classes = (NetlinkError, Pr2mNetlinkError)
-except ModuleNotFoundError:
-    # required for pyroute2 before 0.6.0
-    pass
 
 class ExceptionCollector():
-    def __init__(self, ifname):
+    def __init__(self, ifname, netns):
         self.ifname = ifname
+        self.netns = netns
         self.reset()
 
     def reset(self):
@@ -27,8 +20,9 @@ class ExceptionCollector():
             'args': kwargs,
         })
         if not self.quiet:
-            logger.warning('{} link {} failed: {}'.format(
-                op, self.ifname, excpt.args[1]))
+            logger.warning('{} failed: {}'.format(
+                op, excpt.args[1]),
+                extra={'iface': self.ifname, 'netns': self.netns})
 
     def has_op(self, op):
         for e in self.excpts: