fixed issues in zebra config service, updated config services to start and validate different modes appropriately, added service dependency startup for config services

daemon/core/configservice/base.py

@@ -23,6 +23,10 @@ class ConfigServiceMode(enum.Enum):
     TIMER = 2
 
 
+class ConfigServiceBootError(Exception):
+    pass
+
+
 class ConfigService(abc.ABC):
     # validation period in seconds, how frequent validation is attempted
     validation_period = 0.5
@@ -107,10 +111,16 @@ class ConfigService(abc.ABC):
         raise NotImplementedError
 
     def start(self) -> None:
+        logging.info("node(%s) service(%s) starting...", self.node.name, self.name)
         self.create_dirs()
         self.create_files()
-        self.run_startup()
-        self.run_validation()
+        wait = self.validation_mode == ConfigServiceMode.BLOCKING
+        self.run_startup(wait)
+        if not wait:
+            if self.validation_mode == ConfigServiceMode.TIMER:
+                time.sleep(self.validation_timer)
+            else:
+                self.run_validation()
 
     def stop(self) -> None:
         for cmd in self.shutdown:
@@ -166,13 +176,11 @@ class ConfigService(abc.ABC):
             basename = pathlib.Path(name).name
             if name in self.custom_templates:
                 text = self.custom_templates[name]
-                text = self.clean_text(text)
                 rendered = self.render_text(text, data)
             elif self.templates.has_template(basename):
                 rendered = self.render_template(basename, data)
             else:
                 text = self.get_text_template(name)
-                text = self.clean_text(text)
                 rendered = self.render_text(text, data)
             logging.info(
                 "node(%s) service(%s) template(%s): \n%s",
@@ -183,25 +191,23 @@ class ConfigService(abc.ABC):
             )
             self.node.nodefile(name, rendered)
 
-    def run_startup(self) -> None:
+    def run_startup(self, wait: bool) -> None:
         for cmd in self.startup:
             try:
-                self.node.cmd(cmd)
-            except CoreCommandError:
-                raise CoreError(
-                    f"node({self.node.name}) service({self.name}) "
-                    f"failed startup: {cmd}"
+                self.node.cmd(cmd, wait=wait)
+            except CoreCommandError as e:
+                raise ConfigServiceBootError(
+                    f"node({self.node.name}) service({self.name}) failed startup: {e}"
                 )
 
     def run_validation(self) -> None:
-        wait = self.validation_mode == ConfigServiceMode.BLOCKING
         start = time.monotonic()
-        index = 0
         cmds = self.validate[:]
+        index = 0
         while cmds:
             cmd = cmds[index]
             try:
-                self.node.cmd(cmd, wait=wait)
+                self.node.cmd(cmd)
                 del cmds[index]
                 index += 1
             except CoreCommandError:
@@ -211,10 +217,9 @@ class ConfigService(abc.ABC):
                 )
                 time.sleep(self.validation_period)
 
-            if time.monotonic() - start > 0:
-                raise CoreError(
-                    f"node({self.node.name}) service({self.name}) "
-                    f"failed to validate"
+            if cmds and time.monotonic() - start > 0:
+                raise ConfigServiceBootError(
+                    f"node({self.node.name}) service({self.name}) failed to validate"
                 )
 
     def _render(self, template: Template, data: Dict[str, Any] = None) -> str:
@@ -225,6 +230,7 @@ class ConfigService(abc.ABC):
         )
 
     def render_text(self, text: str, data: Dict[str, Any] = None) -> str:
+        text = self.clean_text(text)
         try:
             template = Template(text)
             return self._render(template, data)
@@ -235,6 +241,13 @@ class ConfigService(abc.ABC):
             )
 
     def render_template(self, basename: str, data: Dict[str, Any] = None) -> str:
+        logging.info(
+            "node(%s) service(%s) rendering template(%s): %s",
+            self.node.name,
+            self.name,
+            basename,
+            data,
+        )
         try:
             template = self.templates.get_template(basename)
             return self._render(template, data)

daemon/core/configservice/dependencies.py

@@ -0,0 +1,97 @@
+import logging
+from typing import TYPE_CHECKING, Dict, List
+
+if TYPE_CHECKING:
+    from core.configservice.base import ConfigService
+
+
+class ConfigServiceDependencies:
+    """
+    Can generate boot paths for services, based on their dependencies. Will validate
+    that all services will be booted and that all dependencies exist within the services provided.
+    """
+
+    def __init__(self, services: Dict[str, "ConfigService"]) -> None:
+        # helpers to check validity
+        self.dependents = {}
+        self.booted = set()
+        self.node_services = {}
+        for service in services.values():
+            self.node_services[service.name] = service
+            for dependency in service.dependencies:
+                dependents = self.dependents.setdefault(dependency, set())
+                dependents.add(service.name)
+
+        # used to find paths
+        self.path = []
+        self.visited = set()
+        self.visiting = set()
+
+    def boot_paths(self) -> List[List["ConfigService"]]:
+        paths = []
+        for name in self.node_services:
+            service = self.node_services[name]
+            if service.name in self.booted:
+                logging.debug(
+                    "skipping service that will already be booted: %s", service.name
+                )
+                continue
+
+            path = self._start(service)
+            if path:
+                paths.append(path)
+
+        if self.booted != set(self.node_services):
+            raise ValueError(
+                "failure to boot all services: %s != %s"
+                % (self.booted, self.node_services.keys())
+            )
+
+        return paths
+
+    def _reset(self) -> None:
+        self.path = []
+        self.visited.clear()
+        self.visiting.clear()
+
+    def _start(self, service: "ConfigService") -> List["ConfigService"]:
+        logging.debug("starting service dependency check: %s", service.name)
+        self._reset()
+        return self._visit(service)
+
+    def _visit(self, current_service: "ConfigService") -> List["ConfigService"]:
+        logging.debug("visiting service(%s): %s", current_service.name, self.path)
+        self.visited.add(current_service.name)
+        self.visiting.add(current_service.name)
+
+        # dive down
+        for service_name in current_service.dependencies:
+            if service_name not in self.node_services:
+                raise ValueError(
+                    "required dependency was not included in node services: %s"
+                    % service_name
+                )
+
+            if service_name in self.visiting:
+                raise ValueError(
+                    "cyclic dependency at service(%s): %s"
+                    % (current_service.name, service_name)
+                )
+
+            if service_name not in self.visited:
+                service = self.node_services[service_name]
+                self._visit(service)
+
+        # add service when bottom is found
+        logging.debug("adding service to boot path: %s", current_service.name)
+        self.booted.add(current_service.name)
+        self.path.append(current_service)
+        self.visiting.remove(current_service.name)
+
+        # rise back up
+        for service_name in self.dependents.get(current_service.name, []):
+            if service_name not in self.visited:
+                service = self.node_services[service_name]
+                self._visit(service)
+
+        return self.path