some refactoring

boswatch/configYaml.py

@@ -23,17 +23,17 @@ logging.debug("- %s loaded", __name__)
 class ConfigYAML:
 
     def __init__(self, config=None):
-        self.__config = config
+        self._config = config
 
     def __iter__(self):
-        for item in self.__config:
+        for item in self._config:
             if type(item) is list or type(item) is dict:
                 yield ConfigYAML(item)
             else:
                 yield item
 
     def __str__(self):
-        return str(self.__config)
+        return str(self._config)
 
     def loadConfigFile(self, configPath):
         """!loads a given configuration
@@ -44,14 +44,14 @@ class ConfigYAML:
         try:
             with open(configPath) as file:
                 # use safe_load instead load
-                self.__config = yaml.safe_load(file)
+                self._config = yaml.safe_load(file)
             return True
         except:  # pragma: no cover
             logging.exception("cannot load config file")
             return False
 
     def get(self, *args, default=None):
-        tmp = self.__config
+        tmp = self._config
         try:
             for arg in args:
                 tmp = tmp.get(arg, default)

boswatch/network/server.py

@@ -22,7 +22,7 @@ import time
 logging.debug("- %s loaded", __name__)
 
 
-class ThreadedTCPRequestHandler(socketserver.ThreadingMixIn, socketserver.BaseRequestHandler):
+class _ThreadedTCPRequestHandler(socketserver.ThreadingMixIn, socketserver.BaseRequestHandler):
     """!ThreadedTCPRequestHandler class for our TCPServer class."""
 
     def handle(self):
@@ -60,7 +60,7 @@ class ThreadedTCPRequestHandler(socketserver.ThreadingMixIn, socketserver.BaseRe
             logging.info("Client disconnected: %s", self.client_address[0])
 
 
-class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
+class _ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
     """!ThreadedTCPServer class for our TCPServer class."""
     pass
 
@@ -98,7 +98,7 @@ class TCPServer:
         @return True or False"""
         try:
             if not self.isRunning:
-                self._server = ThreadedTCPServer(("", port), ThreadedTCPRequestHandler)
+                self._server = _ThreadedTCPServer(("", port), _ThreadedTCPRequestHandler)
                 self._server.timeout = self._timeout
                 self._server.alarmQueue = self._alarmQueue
 

boswatch/router.py

@@ -24,56 +24,57 @@ logging.debug("- %s loaded", __name__)
 
 class _Router:
     def __init__(self, name):
-        self.__name = name
-        self.__route = []
-        logging.debug("[%s] new router", self.__name)
+        self._name = name
+        self._route = []
+        logging.debug("[%s] new router", self._name)
 
     def addRoute(self, route):
-        logging.debug("[%s] add route: %s", self.__name, route)
-        self.__route.append(route)
+        logging.debug("[%s] add route: %s", self._name, route)
+        self._route.append(route)
 
     def runRouter(self, bwPacket):
-        logging.debug("[%s] started", self.__name)
-        for routeCall in self.__route:
-            logging.debug("[%s] -> run route: %s", self.__name, routeCall)
+        logging.debug("[%s] started", self._name)
+        for routeCall in self._route:
+            logging.debug("[%s] -> run route: %s", self._name, routeCall)
             bwPacket_tmp = routeCall(copy.deepcopy(bwPacket))  # copy bwPacket to prevent edit the original
 
             if bwPacket_tmp is None:  # returning None doesnt change the bwPacket
                 continue
 
             if bwPacket_tmp is False:  # returning False stops the router immediately
-                logging.debug("[%s] stopped", self.__name)
+                logging.debug("[%s] stopped", self._name)
                 break
 
             bwPacket = bwPacket_tmp
-            logging.debug("[%s] <- bwPacket returned: %s", self.__name, bwPacket)
-        logging.debug("[%s] ended", self.__name)
+            logging.debug("[%s] <- bwPacket returned: %s", self._name, bwPacket)
+        logging.debug("[%s] ended", self._name)
         return bwPacket
 
     @property
     def name(self):
-        return self.__name
+        return self._name
 
     @property
     def route(self):
-        return self.__route
+        return self._route
 
 
 class RouterManager:
     def __init__(self):
-        self.__routerDict = {}
+        self._routerDict = {}
 
     def __del__(self):
-        del self.__routerDict
+        # destroy all routers (also destroys all instances of modules/plugins)
+        del self._routerDict
 
     def buildRouter(self, config):
-        self.__routerDict = {}  # all routers and loaded modules/plugins would be unloaded
+        self._routerDict = {}  # all routers and instances of modules/plugins would be destroyed
         logging.debug("build routers")
 
         # first we have to init all routers
         # because a router can be a valid target and we need his reference
         for router in config.get("router"):
-            self.__routerDict[router.get("name")] = _Router(router.get("name"))
+            self._routerDict[router.get("name")] = _Router(router.get("name"))
 
         for router in config.get("router"):
             for route in router.get("route"):
@@ -90,32 +91,35 @@ class RouterManager:
                     if routeType == "plugin":
                         importedFile = importlib.import_module(routeType + "." + routeName)
                         loadedClass = importedFile.BoswatchPlugin(route.get("config"))
-                        self.__routerDict[routerName].addRoute(loadedClass._run)
+                        self._routerDict[routerName].addRoute(loadedClass._run)
 
                     elif routeType == "module":
                         importedFile = importlib.import_module(routeType + "." + routeName)
                         loadedClass = importedFile.BoswatchModule(route.get("config"))
-                        self.__routerDict[routerName].addRoute(loadedClass._run)
+                        self._routerDict[routerName].addRoute(loadedClass._run)
 
                     elif routeType == "router":
-                        self.__routerDict[routerName].addRoute(self.__routerDict[routeName].runRouter)
+                        self._routerDict[routerName].addRoute(self._routerDict[routeName].runRouter)
 
                     else:
                         logging.warning("unknown type: %s", routeType)
 
                 except ModuleNotFoundError:
                     logging.error("%s not found: %s", route.get("type"), route.get("name"))
-                    
+
         logging.debug("finished building routers")
         self._showRouterRoute()
 
     def runRouter(self, routerList, bwPacket):
-        for router in routerList:
-            if router in self.__routerDict:
-                self.__routerDict[router].runRouter(bwPacket)
+        if type(routerList) is str:  # convert single string name to list
+            routerList = [routerList]
+
+        for routerName in routerList:
+            if routerName in self._routerDict:
+                self._routerDict[routerName].runRouter(bwPacket)
 
     def _showRouterRoute(self):
-        for name, router in self.__routerDict.items():
+        for name, router in self._routerDict.items():
             logging.debug("Route for %s", name)
-            for route in router.route:
-                logging.debug(" | %s", route)
+            for routePoint in router.route:
+                logging.debug(" | %s", routePoint)

router_test.py

@@ -5,7 +5,6 @@ from boswatch.configYaml import ConfigYAML
 from boswatch.packet import Packet
 from boswatch.router import RouterManager
 
-
 config = ConfigYAML()
 config.loadConfigFile("config/server.yaml")
 
@@ -20,6 +19,9 @@ routMan.buildRouter(config)
 print()
 routMan.runRouter(config.get("alarmRouter"), bwPack)
 
+print()
+routMan.runRouter("Router 2", bwPack)
+
 
 print()
 exit()