ifstate 1.8.2__tar.gz → 1.8.4__tar.gz

{ifstate-1.8.2 → ifstate-1.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ifstate
-Version: 1.8.2
+Version: 1.8.4
 Summary: Manage host interface settings in a declarative manner
 Home-page: https://ifstate.net/
 Author: Thomas Liske

{ifstate-1.8.2 → ifstate-1.8.4}/ifstate/ifstate.py

@@ -86,7 +86,7 @@ def main():
         shell()
         exit(0)
 
-    ifslog = IfStateLogging(lvl)
+    ifslog = IfStateLogging(lvl, action=args.action)
     ifs = IfState()
 
     if args.action in [Actions.SHOW, Actions.SHOWALL]:
@@ -137,7 +137,7 @@ def main():
                 pass
         elif args.action == Actions.VRRP_FIFO:
             status_pattern = re.compile(
-                r'(group|instance) "([^"]+)" (unknown|fault|backup|master)$', re.IGNORECASE)
+                r'(group|instance) "([^"]+)" (unknown|fault|backup|master)( \d+)?$', re.IGNORECASE)
 
             with open(args.fifo) as fifo:
                 for line in fifo:

{ifstate-1.8.2 → ifstate-1.8.4}/ifstate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ifstate
-Version: 1.8.2
+Version: 1.8.4
 Summary: Manage host interface settings in a declarative manner
 Home-page: https://ifstate.net/
 Author: Thomas Liske

{ifstate-1.8.2 → ifstate-1.8.4}/ifstate.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ libifstate/brport/__init__.py
 libifstate/link/__init__.py
 libifstate/link/base.py
 libifstate/link/physical.py
+libifstate/link/tun.py
 libifstate/link/veth.py
 libifstate/neighbour/__init__.py
 libifstate/parser/__init__.py

{ifstate-1.8.2 → ifstate-1.8.4}/libifstate/__init__.py

@@ -43,7 +43,7 @@ import json
 import errno
 import logging
 
-__version__ = "1.8.2"
+__version__ = "1.8.4"
 
 
 class IfState():
@@ -262,11 +262,21 @@ class IfState():
 
     def _apply(self, do_apply, vrrp_type, vrrp_name, vrrp_state):
         vrrp_ignore = []
-        vrrp_remove = []
+        vrrp_disable = []
 
         by_vrrp = not None in [
             vrrp_type, vrrp_name, vrrp_state]
 
+        if by_vrrp:
+            logger.info("vrrp state change: {} {} => {}".format(vrrp_type, vrrp_name, vrrp_state))
+
+            # ifstate schema requires lower case keywords
+            vrrp_type = vrrp_type.lower()
+            vrrp_state = vrrp_state.lower()
+
+        # check which links to remove or ignore:
+        #   remove: vrrp type & name matches, but vrrp state not
+        #   ignore: vrrp type & name does not match
         for ifname, link in self.links.items():
             if ifname in self.vrrp['links']:
                 if not by_vrrp:
@@ -275,9 +285,11 @@ class IfState():
                     if not link.match_vrrp_select(vrrp_type, vrrp_name):
                         vrrp_ignore.append(ifname)
                     elif not vrrp_name in self.vrrp[vrrp_type] or not vrrp_state in self.vrrp[vrrp_type][vrrp_name] or not ifname in self.vrrp[vrrp_type][vrrp_name][vrrp_state]:
-                        vrrp_remove.append(ifname)
+                        vrrp_disable.append(ifname)
             elif by_vrrp:
                 vrrp_ignore.append(ifname)
+        logger.debug("vrrp links to be disabled: {}".format(", ".join(vrrp_disable)))
+        logger.debug("vrrp links to be ignored: {}".format(", ".join(vrrp_ignore)))
 
         self.ipaddr_ignore = set()
         for ip in self.ignore.get('ipaddr', []):
@@ -299,10 +311,10 @@ class IfState():
             if stage == 0:
                 logger.info("\nconfiguring interface links")
 
-                for ifname in vrrp_remove:
-                    logger.debug('to be removed due to vrrp constraint',
+                for ifname in vrrp_disable:
+                    logger.debug('to be disabled due to vrrp constraint',
                                  extra={'iface': ifname})
-                    del self.links[ifname]
+                    self.links[ifname].settings['state'] = 'down'
             else:
                 logger.info("\nconfiguring interface links (stage 2)")
 
@@ -325,7 +337,7 @@ class IfState():
                         applied.append(name)
                     else:
                         deps = link.depends()
-                        if all(x in applied for x in deps):
+                        if all(x in applied+vrrp_ignore for x in deps):
                             excpts = link.apply(do_apply, self.sysctl)
                             if excpts.has_errno(errno.EEXIST):
                                 retry = True

{ifstate-1.8.2 → ifstate-1.8.4}/libifstate/link/__init__.py

@@ -1,3 +1,4 @@
 import libifstate.link.base
 import libifstate.link.physical
+import libifstate.link.tun
 import libifstate.link.veth

{ifstate-1.8.2 → ifstate-1.8.4}/libifstate/link/base.py

@@ -66,6 +66,11 @@ class Link(ABC):
             1: "bandwidth",
             2: "count",
         },
+        # === tuntap ===
+        'tun_type': {
+            1: 'tun',
+            2: 'tap',
+        },
         # === vlan ===
         'vlan_protocol': {
             0x88a8: '802.1ad',
@@ -108,7 +113,7 @@ class Link(ABC):
                          'ip6gre_link', 'vxlan_link', 'xfrm_link']
         self.idx = None
 
-        if 'address' in self.settings:
+        if 'address' in self.settings and self.settings['kind'] == 'physical':
             self.settings['address'] = self.settings['address'].lower()
             self.idx = next(iter(ipr.link_lookup(
                 address=self.settings['address'])), None)
@@ -369,7 +374,7 @@ class Link(ABC):
                     raise
                 excpts.add('del', err)
         self.idx = None
-        self.create(do_apply, ifstate, excpts, "replace")
+        self.create(do_apply, sysctl, excpts, "replace")
 
     def update(self, do_apply, sysctl, excpts):
         logger.debug('checking link', extra={'iface': self.settings['ifname']})
@@ -505,13 +510,14 @@ class Link(ABC):
                 self.brport.apply(do_apply, self.idx, excpts)
 
             if has_state_changes:
-                try:
-                    ipr.link('set', index=self.idx,
-                             state=self.settings["state"])
-                except Exception as err:
-                    if not isinstance(err, netlinkerror_classes):
-                        raise
-                    excpts.add('set', err, state=state)
+                if do_apply:
+                    try:
+                        ipr.link('set', index=self.idx,
+                                 state=self.settings["state"])
+                    except Exception as err:
+                        if not isinstance(err, netlinkerror_classes):
+                            raise
+                        excpts.add('set', err, state=state)
                 logger.info('change', extra={
                             'iface': self.settings['ifname'], 'style': IfStateLogging.STYLE_CHG})
 

ifstate-1.8.4/libifstate/link/tun.py

@@ -0,0 +1,23 @@
+from libifstate.util import logger
+from libifstate.link.base import Link
+from libifstate.exception import LinkCannotAdd
+
+from pwd import getpwnam
+from grp import getgrnam
+
+class TunLink(Link):
+    def __init__(self, name, link, ethtool, 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__(name, link, ethtool, vrrp, brport)
+        self.cap_create = bool(link.get('tun_persist'))
+ 
+    def create(self, do_apply, sysctl, excpts, oper="add"):
+        if not self.cap_create:
+            logger.warning('Unable to create missing non-persistent tuntap link: {}'.format(self.settings.get('ifname')))
+        else:
+            super().create(do_apply, sysctl, excpts, oper)

{ifstate-1.8.2 → ifstate-1.8.4}/libifstate/log.py

@@ -1,44 +1,46 @@
 import logging
 from logging.handlers import QueueHandler, QueueListener
+import os
 import queue
 import sys
 
 logger = logging.getLogger('ifstate')
+logger.propagate = False
+
+formatter = logging.Formatter('%(bol)s%(prefix)s%(style)s%(message)s%(eol)s')
 
 class IfStateLogFilter(logging.Filter):
-    def __init__(self, terminal):
+    def __init__(self, is_terminal):
         super().__init__()
-        self.terminal = terminal
+        self.is_terminal = is_terminal
 
     def filter(self, record):
         record.levelshort = record.levelname[:1]
+
         if hasattr(record, 'iface'):
             record.prefix = " {:15} ".format(record.iface)
         else:
             record.prefix = ''
 
-        if self.terminal:
+        if self.is_terminal and record.levelno >= logging.WARNING:
             if record.levelno >= logging.ERROR:
                 record.bol = IfStateLogging.ANSI_RED
-            elif record.levelno >= logging.WARNING:
-                record.bol = IfStateLogging.ANSI_MAGENTA
             else:
-                record.bol = ''
+                record.bol = IfStateLogging.ANSI_MAGENTA
             record.eol = IfStateLogging.ANSI_RESET
         else:
             record.bol = ''
             record.eol = ''
 
-        if hasattr(record, 'style'):
-            if self.terminal:
-                record.style = IfStateLogging.colorize(record.style)
-            else:
-                record.style = ""
+        if self.is_terminal and hasattr(record, 'style'):
+            record.style = IfStateLogging.colorize(record.style)
+            record.eol = IfStateLogging.ANSI_RESET
         else:
             record.style = ""
 
         return True
 
+
 class IfStateLogging:
     STYLE_OK = "ok"
     STYLE_CHG = "chg"
@@ -61,22 +63,44 @@ class IfStateLogging:
             return IfStateLogging.ANSI_YELLOW
         return ""
 
-    def __init__(self, level, handlers=[]):
+    def __init__(self, level, handlers=[], action=None):
         if level != logging.DEBUG:
             sys.tracebacklimit = 0
 
         logging.basicConfig(
             level=level,
-            format='%(bol)s%(prefix)s%(style)s%(message)s%(eol)s',
         )
 
-        is_terminal = sys.stderr is not None and sys.stderr.isatty()
-        f = IfStateLogFilter(is_terminal)
-        logger.addFilter(f)
+        has_stderr = sys.stderr is not None
+        is_terminal = has_stderr and sys.stderr.isatty()
+
+        # add custom logging handlers
+        if not handlers:
+            handlers = []
+
+            if has_stderr:
+                # log to stderr
+                stream = logging.StreamHandler(sys.stderr)
+                stream.addFilter(IfStateLogFilter(is_terminal))
+                stream.setFormatter(formatter)
+                handlers.append(stream)
+
+            # log to syslog
+            syslog = logging.handlers.SysLogHandler('/dev/log', facility=logging.handlers.SysLogHandler.LOG_DAEMON)
+            if action is None:
+                syslog.ident = 'ifstate[{}] '.format(os.getpid())
+            else:
+                syslog.ident = 'ifstate-{}[{}] '.format(action, os.getpid())
+            syslog.addFilter(IfStateLogFilter(False))
+            syslog.setFormatter(formatter)
+            handlers.append(syslog)
 
         qu = queue.SimpleQueue()
-        logger.addHandler(QueueHandler(qu))
-        self.listener = QueueListener(qu, *handlers, respect_handler_level=True)
+        queue_handler = QueueHandler(qu)
+        queue_handler.setLevel(level)
+        logger.addHandler(queue_handler)
+        self.listener = QueueListener(
+            qu, *handlers, respect_handler_level=True)
         self.listener.start()
 
     def quit(self):

{ifstate-1.8.2 → ifstate-1.8.4}/schema/ifstate.conf.schema.json

@@ -1449,13 +1449,15 @@
                                 }
                             },
                             {
-                                "description": "Virtual software device",
+                                "description": "Virtual software device (TUN/TAP)",
                                 "required": [
-                                    "kind"
+                                    "kind",
+                                    "tun_type"
                                 ],
+                                "additionalProperties": false,
                                 "properties": {
                                     "kind": {
-                                        "const": "tuntap",
+                                        "const": "tun",
                                         "description": "link type"
                                     },
                                     "address": {
@@ -1478,6 +1480,82 @@
                                     },
                                     "ifalias": {
                                         "$ref": "#/$defs/iface-link_ifalias"
+                                    },
+                                    "tun_type": {
+                                        "description": "device mode (Ethernet headers)",
+                                        "default": "tap",
+                                        "enum": [
+                                            1,
+                                            "tun",
+                                            2,
+                                            "tap"
+                                        ]
+                                    },
+                                    "tun_pi": {
+                                        "description": "provide packet information",
+                                        "type": [
+                                            "boolean",
+                                            "integer"
+                                        ],
+                                        "default": false,
+                                        "enum": [
+                                            0,
+                                            false,
+                                            1,
+                                            true
+                                        ]
+                                    },
+                                    "tun_persist": {
+                                        "description": "persistent device; non-persistent devices cannot be created",
+                                        "type": [
+                                            "boolean",
+                                            "integer"
+                                        ],
+                                        "default": false,
+                                        "enum": [
+                                            0,
+                                            false,
+                                            1,
+                                            true
+                                        ]
+                                    },
+                                    "tun_vnet_hdr": {
+                                        "description": "prepend frames with struct virtio_net_hdr",
+                                        "default": false,
+                                        "enum": [
+                                            0,
+                                            false,
+                                            1,
+                                            true
+                                        ]
+                                    },
+                                    "tun_multi_queue": {
+                                        "description": "enable multiqueue tuntap",
+                                        "type": [
+                                            "boolean",
+                                            "integer"
+                                        ],
+                                        "default": false,
+                                        "enum": [
+                                            0,
+                                            false,
+                                            1,
+                                            true
+                                        ]
+                                    },
+                                    "tun_owner": {
+                                        "description": "device owner",
+                                        "type": [
+                                            "integer",
+                                            "string"
+                                        ]
+                                    },
+                                    "tun_group": {
+                                        "description": "device group",
+                                        "type": [
+                                            "integer",
+                                            "string"
+                                        ]
                                     }
                                 }
                             },