ifstate 1.12.0__tar.gz → 1.13.0__tar.gz

{ifstate-1.12.0 → ifstate-1.13.0}/PKG-INFO

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

{ifstate-1.12.0 → ifstate-1.13.0}/ifstate/ifstate.py

@@ -24,16 +24,18 @@ class Actions():
     SHOWALL = "showall"
     VRRP = "vrrp"
     VRRP_FIFO = "vrrp-fifo"
+    VRRP_WORKER = "vrrp-worker"
     SHELL = "shell"
 
 ACTIONS_HELP = {
-    "CHECK"    : "dry run update the network config",
-    "APPLY"    : "update the network config",
-    "SHOW"     : "show running network config",
-    "SHOWALL"  : "show running network config (more settings)",
-    "VRRP"     : "run as keepalived notify script",
-    "VRRP_FIFO": "run as keepalived notify_fifo_script",
-    "SHELL"    : "launch interactive python shell (pyroute2)",
+    "CHECK"      : "dry run update the network config",
+    "APPLY"      : "update the network config",
+    "SHOW"       : "show running network config",
+    "SHOWALL"    : "show running network config (more settings)",
+    "VRRP"       : "run as keepalived notify script",
+    "VRRP_FIFO"  : "run as keepalived notify_fifo_script",
+    "VRRP_WORKER": "worker process for vrrp-fifo",
+    "SHELL"      : "launch interactive python shell (pyroute2)",
 }
 
 class IfsConfigHandler():
@@ -41,23 +43,22 @@ class IfsConfigHandler():
         self.fn = fn
         self.soft_schema = soft_schema
 
+        # require to be called from the root netns
+        try:
+            # assume init runs in the root netns
+            if os.readlink('/proc/1/ns/net') != os.readlink(f'/proc/{os.getpid()}/ns/net'):
+                logger.error("Must not be run from inside a netns!")
+                raise NetNSNotRoot()
+        except OSError as ex:
+            logger.debug(f'root netns test: {ex}')
+            pass
+
         self.ifs = self.load_config()
         self.cb = None
 
-    def set_callback(self, cb):
-        self.cb = cb
-
-    def sighup_handler(self, signum, frame):
-        logger.info("SIGHUP: reloading configuration")
-        try:
-            self.ifs = self.load_config()
-            self.cb(self.ifs)
-        except:
-            logger.exception("failed to reload configuration")
-
     def load_config(self):
         try:
-            parser = YamlParser(self.fn)
+            self.parser = YamlParser(self.fn)
         except ParserOpenError as ex:
             logger.error(
                 "Config loading from {} failed: {}".format(ex.fn, ex.msg))
@@ -71,10 +72,8 @@ class IfsConfigHandler():
             raise ex
 
         try:
-            ifstates = parser.config()
-
             ifs = IfState()
-            ifs.update(ifstates, self.soft_schema)
+            ifs.update(self.parser.config(), self.soft_schema)
             return ifs
         except ParserValidationError as ex:
             logger.error("Config validation failed for {}".format(ex.detail))
@@ -83,10 +82,14 @@ class IfsConfigHandler():
             logger.error(
                 "Config uses unavailable feature: {}".format(ex.feature))
             raise ex
-        except NetNSNotRoot as ex:
-            logger.error("Must not be run from inside a netns!")
-            raise ex
 
+    def dump_config(self, fn):
+        umask = os.umask(0o077)
+        try:
+            with open(fn, "w") as fh:
+                self.parser.dump(fh)
+        finally:
+            os.umask(umask)        
 
 def shell():
     from ifstate.shell import IfStateConsole
@@ -151,6 +154,12 @@ def main():
     action_parsers[Actions.VRRP_FIFO].add_argument(
         "fifo", type=str, help="named FIFO to read state changes from")
 
+    # Parameters for the vrrp-worker action
+    action_parsers[Actions.VRRP_WORKER].add_argument(
+        "type", type=str.lower, choices=["group", "instance"], help="type of vrrp notification")
+    action_parsers[Actions.VRRP_WORKER].add_argument(
+        "name", type=str, help="name of the vrrp group or instance")
+
     args = parser.parse_args()
     if args.verbose:
         lvl = logging.DEBUG
@@ -181,7 +190,7 @@ def main():
         ifslog.quit()
         exit(0)
 
-    if args.action in [Actions.CHECK, Actions.APPLY, Actions.VRRP, Actions.VRRP_FIFO]:
+    if args.action in [Actions.CHECK, Actions.APPLY, Actions.VRRP, Actions.VRRP_FIFO, Actions.VRRP_WORKER]:
         try:
             ifs_config = IfsConfigHandler(args.config, args.soft_schema)
         except (ParserOpenError,
@@ -203,7 +212,10 @@ def main():
                 exit(ex.exit_code())
         elif args.action == Actions.VRRP_FIFO:
             from ifstate.vrrp import vrrp_fifo
-            vrrp_fifo(args.fifo, ifs_config, lvl)
+            vrrp_fifo(args.fifo, ifs_config)
+        elif args.action == Actions.VRRP_WORKER:
+            from ifstate.vrrp import vrrp_worker
+            vrrp_worker(args.type, args.name, ifs_config)
         else:
             # ignore some well-known signals to prevent interruptions (i.e. due to ssh connection loss)
             signal.signal(signal.SIGHUP, signal.SIG_IGN)

ifstate-1.13.0/ifstate/vrrp.py

@@ -0,0 +1,166 @@
+from libifstate.util import logger, IfStateLogging
+
+import atexit
+from copy import deepcopy
+import logging
+import multiprocessing as mp
+import threading
+import os
+import re
+from setproctitle import setproctitle
+import signal
+import subprocess
+import sys
+
+class VrrpFifoProcess():
+    '''
+    Process for vrrp group/instance configuration.
+    '''
+    def __init__(self, worker_args):
+        self.worker_args = worker_args
+        self.logger_extra = {'iface': f'{worker_args[-2]} "{worker_args[-1]}"'}
+        self.state_queue = mp.Queue()
+        self.worker_proc = None
+
+        worker_io = threading.Thread(target=self.dequeue)
+        worker_io.start()
+
+    def vrrp_update(self, vrrp_state):
+        self.state_queue.put(vrrp_state)
+
+    def dequeue(self):
+        while True:
+            state = self.state_queue.get()
+
+            # Should we terminate?
+            if state is None:
+                self.worker_proc.stdin.close()
+                self.worker_proc.wait()
+                return
+
+            # Restart ifstate vrrp-worker if not alive alive?
+            if self.worker_proc.poll() is not None:
+                logger.warning("worker died", extra=self.logger_extra)
+                self.start()
+
+            logger.info(f'state => {state}', extra=self.logger_extra)
+            self.worker_proc.stdin.write(f'{state}\n')
+            self.worker_proc.stdin.flush()
+        logger.warning("dequeue terminated")
+
+    def start(self):
+        logger.info("spawning worker", extra=self.logger_extra)
+        self.worker_proc = subprocess.Popen(self.worker_args, stdin=subprocess.PIPE, stderr=sys.stderr, text=True)
+
+
+class VrrpStates():
+    '''
+    Tracks processes and states for vrrp groups/instances.
+    '''
+    def __init__(self, ifs_config):
+        self.ifs_config = ifs_config
+        self.processes = {}
+        self.states = {}
+        self.pid_file = f"/run/libifstate/vrrp/{os.getpid()}.pid"
+        self.cfg_file = f"/run/libifstate/vrrp/{os.getpid()}.cfg"
+        self.worker_args = (
+            sys.argv[0],
+            '-c', self.cfg_file,
+            'vrrp-worker')
+        if logger.level == logging.DEBUG:
+            self.worker_args.append('-v')
+
+    def update(self, vrrp_type, vrrp_name, vrrp_state):
+        '''
+        Updates the state for a group/instance. A new VrrpFifoProcess is spawned on-demand
+        if a group/instance is called the first time.
+        '''
+        key = (vrrp_type, vrrp_name)
+        if not key in self.processes:
+            worker_args = self.worker_args + key
+            self.processes[key] = VrrpFifoProcess(worker_args)
+            self.processes[key].start()
+
+        self.states[key] = vrrp_state
+        self.processes[key].vrrp_update(vrrp_state)
+
+    def reconfigure(self, *argv):
+        '''
+        Reconfigure all known groups/instances using their last known state by spawning
+        new worker Processes.
+        '''
+
+        # save new config to temp file
+        try:
+            self.ifs_config.load_config()
+            self.ifs_config.dump_config(self.cfg_file)
+        except Exception as ex:
+            logger.error(f'failed to reload config: {ex}')
+            return
+
+        for key, state in self.states.items():
+            worker_args = self.worker_args + key
+            self.processes[key].vrrp_update(None)
+            self.processes[key] = VrrpFifoProcess(worker_args)
+            self.processes[key].start()
+            self.processes[key].vrrp_update(self.states[key])
+
+    def cleanup_run(self, *argv):
+        """
+        """
+        for file in [self.pid_file, self.cfg_file]:
+            try:
+                os.unlink(file)
+            except OSError as ex:
+                if ex.errno != 2:
+                    logger.warning(f"cannot cleanup {file}: {ex}")
+
+def vrrp_fifo(args_fifo, ifs_config):
+    vrrp_states = VrrpStates(ifs_config)
+
+    signal.signal(signal.SIGHUP, vrrp_states.reconfigure)
+    signal.signal(signal.SIGPIPE, signal.SIG_IGN)
+    signal.signal(signal.SIGTERM, vrrp_states.cleanup_run)
+
+    try:
+        os.makedirs("/run/libifstate/vrrp", exist_ok=True)
+
+        with open(vrrp_states.pid_file, "w", encoding="utf-8") as fh:
+            fh.write(args_fifo)
+        atexit.register(vrrp_states.cleanup_run)
+
+        ifs_config.dump_config(vrrp_states.cfg_file)
+    except IOError as err:
+        logger.exception(f'failed to write pid file {vrrp_states.pid_file}: {err}')
+
+    try:
+        status_pattern = re.compile(
+            r'(group|instance) "([^"]+)" (unknown|fault|backup|master|stop)( \d+)?$', re.IGNORECASE)
+
+        with open(args_fifo) as fifo:
+            logger.debug("entering fifo loop...")
+            for line in fifo:
+                m = status_pattern.match(line.strip())
+                if m:
+                    vrrp_type = m.group(1)
+                    vrrp_name = m.group(2)
+                    vrrp_state = m.group(3)
+
+                    vrrp_states.update(vrrp_type, vrrp_name, vrrp_state)
+                else:
+                    logger.warning(f'failed to parse fifo input: {line.strip()}')
+                mp.active_children()
+    finally:
+        vrrp_states.cleanup_run()
+
+def vrrp_worker(vrrp_type, vrrp_name, ifs_config):
+    instance_title = "vrrp-{}-{}".format(vrrp_type, vrrp_name)
+    setproctitle("ifstate-{}".format(instance_title))
+
+    logger.info('worker is alive')
+    for state in sys.stdin:
+        vrrp_state = state.strip()
+
+        ifstate = deepcopy(ifs_config.ifs)
+        ifstate.apply(vrrp_type, vrrp_name, vrrp_state)
+    logger.info('terminating')

{ifstate-1.12.0 → ifstate-1.13.0}/ifstate.egg-info/PKG-INFO

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

{ifstate-1.12.0 → ifstate-1.13.0}/libifstate/__init__.py

@@ -6,7 +6,7 @@ from libifstate.neighbour import Neighbours
 from libifstate.routing import Tables, Rules, RTLookups
 from libifstate.parser import Parser
 from libifstate.tc import TC
-from libifstate.exception import netlinkerror_classes, NetNSNotRoot
+from libifstate.exception import netlinkerror_classes
 import bisect
 import os
 import pyroute2
@@ -48,7 +48,7 @@ import json
 import errno
 import logging
 
-__version__ = "1.12.0"
+__version__ = "1.13.0"
 
 
 class IfState():
@@ -120,14 +120,6 @@ class IfState():
 
         self._update(self.root_netns, ifstates)
         if 'namespaces' in ifstates:
-            # require to called from the root netns
-            try:
-                # assume init runs in the root netns
-                if os.readlink('/proc/1/ns/net') != os.readlink(f'/proc/{os.getpid()}/ns/net'):
-                    raise NetNSNotRoot()
-            except OSError as ex:
-                logger.debug(f'root netns test: {ex}')
-                pass
             self.namespaces = {}
             self.new_namespaces = []
             for netns_name, netns_ifstates in ifstates['namespaces'].items():

{ifstate-1.12.0 → ifstate-1.13.0}/libifstate/parser/base.py

@@ -150,3 +150,10 @@ class Parser(ABC):
                 del(cfg["ignore"][k])
 
         return cfg
+
+    @abstractmethod
+    def dump(self, stream):
+        """
+        Dump the parsed configuration into a io stream.
+        """
+        pass

{ifstate-1.12.0 → ifstate-1.13.0}/libifstate/parser/yaml.py

@@ -42,3 +42,6 @@ class YamlParser(Parser):
             raise ParserOpenError(ex)
         except yaml.parser.ParserError as ex:
             raise ParserParseError(ex)
+
+    def dump(self, stream):
+        yaml.dump(self.config(), stream)

{ifstate-1.12.0 → ifstate-1.13.0}/libifstate/routing/__init__.py

@@ -61,7 +61,7 @@ class RTLookup():
         self.str2id = {}
         self.id2str = {}
 
-        for basedir in ['/usr/lib/iproute2', '/etc/iproute2']:
+        for basedir in ['/usr/share/iproute2', '/usr/lib/iproute2', '/etc/iproute2']:
             fn = os.path.join(basedir, name)
             try:
                 with open(fn, 'r') as fp:
@@ -307,7 +307,7 @@ class Tables(collections.abc.Mapping):
 
             kroutes = self.kernel_routes(table)
 
-            for route in croutes:
+            for route in sorted(croutes, key=lambda x: [x.get('via', ''), x['dst']]):
                 if 'oif' in route and type(route['oif']) == str:
                     oif = next(
                         iter(self.netns.ipr.link_lookup(ifname=route['oif'])), None)

{ifstate-1.12.0 → ifstate-1.13.0}/libifstate/util.py

@@ -23,6 +23,7 @@ import struct
 import array
 import struct
 import typing
+import os
 
 # ethtool helper
 ETHTOOL_GDRVINFO = 0x00000003  # Get driver info
@@ -64,6 +65,23 @@ class IPRouteExt(IPRoute):
 
         self.__sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 
+
+
+    # def fork_before():
+    #     import sys
+    #     print(f"FORK[{os.getpid()}] before", file=sys.stderr)
+
+    # def fork_parent():
+    #     import sys
+    #     print(f"FORK[{os.getpid()}] parent", file=sys.stderr)
+
+    # def fork_child():
+    #     import sys
+    #     print(f"FORK[{os.getpid()}] after", file=sys.stderr)
+
+    # os.register_at_fork(before=fork_before, after_in_parent=fork_parent, after_in_child=fork_child)
+
+
     def del_filter_by_info(self, index=0, handle=0, info=0, parent=0):
         msg = tcmsg()
         msg['index'] = index
@@ -173,7 +191,7 @@ class IPRouteExt(IPRoute):
         try:
             return next(iter(self.get_links(*argv, **kwarg)), None)
         except Exception as err:
-            if not isinstance(err, netlinkerror_classes):
+            if not isinstance(err, libifstate.exception.netlinkerror_classes):
                 raise
 
         return None

{ifstate-1.12.0 → ifstate-1.13.0}/schema/ifstate.conf.schema.json

@@ -2,7 +2,7 @@
     "$id": "https://ifstate.net/schema/ifstate.conf.schema.json",
     "$schema": "http://json-schema.org/draft-07/schema#",
     "title": "ifstate.conf",
-    "description": "IfState 1.11.9 Configuration Schema",
+    "description": "IfState 1.13 Configuration Schema",
     "type": "object",
     "required": [
         "interfaces"
@@ -3015,6 +3015,32 @@
                                         "description": "specifies the maximum number of FDB entries (0: none)",
                                         "default": 0
                                     },
+                                    "vxlan_port": {
+                                        "description": "specifies the UDP destination port to communicate to the remote VXLAN tunnel endpoint",
+                                        "type": "integer",
+                                        "minimum": 0,
+                                        "maximum": 65535
+                                    },
+                                    "vxlan_port_range": {
+                                        "description": "specifies the range of port numbers to use as UDP source ports to communicate to the remote VXLAN tunnel endpoint",
+                                        "required": [
+                                            "low",
+                                            "high"
+                                        ],
+                                        "additionalProperties": false,
+                                        "properties": {
+                                            "low": {
+                                                "type": "integer",
+                                                "minimum": 0,
+                                                "maximum": 65535
+                                            },
+                                            "high": {
+                                                "type": "integer",
+                                                "minimum": 0,
+                                                "maximum": 65535
+                                            }
+                                        }
+                                    },
                                     "vxlan_proxy": {
                                         "type": "integer",
                                         "minimum": 0,

ifstate-1.12.0/ifstate/vrrp.py

@@ -1,113 +0,0 @@
-from libifstate.util import logger, IfStateLogging
-
-from copy import deepcopy
-import logging
-import multiprocessing as mp
-import os
-import re
-from setproctitle import setproctitle
-import signal
-
-class VrrpFifoProcess(mp.Process):
-    '''
-    Process for vrrp group/instance configuration.
-    '''
-    def __init__(self, vrrp_type, vrrp_name, ifstate, log_level):
-        self.vrrp_type = vrrp_type
-        self.vrrp_name = vrrp_name
-        self.ifstate = ifstate
-        self.log_level = log_level
-        self.queue = mp.Queue()
-        super().__init__(target=self.vrrp_worker, name=f'ifstate-vrrp-fifo|{vrrp_type}.{vrrp_name}', daemon=True)
-
-    def vrrp_update(self, vrrp_state):
-        self.queue.put(vrrp_state)
-
-    def vrrp_worker(self):
-        instance_title = "vrrp-{}-{}".format(self.vrrp_type, self.vrrp_name)
-        setproctitle("ifstate-{}".format(instance_title))
-        ifslog = IfStateLogging(self.log_level, action=instance_title, log_stderr=False)
-        logger.info('worker spawned')
-        while True:
-            vrrp_state = self.queue.get()
-            if vrrp_state is None:
-                logger.info('terminating')
-                return
-            else:
-                ifstate = deepcopy(self.ifstate)
-                ifstate.apply(self.vrrp_type, self.vrrp_name, vrrp_state)
-
-class VrrpStates():
-    '''
-    Tracks processes and states for vrrp groups/instances.
-    '''
-    def __init__(self, ifstate, log_level):
-        self.ifstate = ifstate
-        self.log_level = log_level
-        self.processes = {}
-        self.states = {}
-
-    def update(self, vrrp_type, vrrp_name, vrrp_state):
-        '''
-        Updates the state for a group/instance. A new VrrpFifoProcess is spawned on-demand
-        if a group/instance is called the first time.
-        '''
-        key = (vrrp_type, vrrp_name)
-        if not key in self.processes:
-            self.processes[key] = VrrpFifoProcess(vrrp_type, vrrp_name, self.ifstate, self.log_level)
-            self.processes[key].start()
-
-        self.states[key] = vrrp_state
-        self.processes[key].vrrp_update(vrrp_state)
-
-    def reconfigure(self, ifstate):
-        '''
-        Reconfigure all known groups/instances using their last known state by spawning
-        new worker Processes.
-        '''
-        self.ifstate = ifstate
-        for key, state in self.states.items():
-            self.processes[key].vrrp_update(None)
-            self.processes[key] = VrrpFifoProcess(*key, ifstate, self.log_level)
-            self.processes[key].start()
-            self.processes[key].vrrp_update(self.states[key])
-
-def vrrp_fifo(args_fifo, ifs_config, log_level):
-    vrrp_states = VrrpStates(ifs_config.ifs, log_level)
-    ifs_config.set_callback(vrrp_states.reconfigure)
-
-    signal.signal(signal.SIGHUP, ifs_config.sighup_handler)
-    signal.signal(signal.SIGPIPE, signal.SIG_IGN)
-    signal.signal(signal.SIGTERM, signal.SIG_IGN)
-
-    pid_file = f"/run/libifstate/vrrp/{os.getpid()}.pid"
-    try:
-        os.makedirs("/run/libifstate/vrrp", exist_ok=True)
-
-        with open(pid_file, "w", encoding="utf-8") as fh:
-            fh.write(args_fifo)
-    except IOError as err:
-        logger.exception(f'failed to write pid file {pid_file}: {err}')
-
-    try:
-        status_pattern = re.compile(
-            r'(group|instance) "([^"]+)" (unknown|fault|backup|master)( \d+)?$', re.IGNORECASE)
-
-        with open(args_fifo) as fifo:
-            logger.debug("entering fifo loop...")
-            for line in fifo:
-                m = status_pattern.match(line.strip())
-                if m:
-                    vrrp_type = m.group(1)
-                    vrrp_name = m.group(2)
-                    vrrp_state = m.group(3)
-
-                    vrrp_states.update(vrrp_type, vrrp_name, vrrp_state)
-                else:
-                    logger.warning(f'failed to parse fifo input: {line.strip()}')
-                mp.active_children()
-    finally:
-        try:
-            os.remove(pid_file)
-        except IOError:
-            pass