boswatch.router.router.Router Class Reference

Class for the Router. More...

Public Member Functions
	__init__ (self, name)
	Create a new router.
	addRoute (self, route)
	Adds a route point to the router.
	runRouter (self, bwPacket)
	Run the router.

Data Fields
	name
	routeList

Protected Member Functions
	_process_route_recursive (self, bwPacket, start_index)
	Recursively process the route to support list branching (e.g.
	_getStatistics (self)
	Returns statistical information's from last router run.

Protected Attributes
	_cumTime
	_routerTime
	_runCount

Detailed Description

Class for the Router.

Constructor & Destructor Documentation

__init__()

boswatch.router.router.Router.__init__	(		self,
			name
	)

Create a new router.

Parameters

name	name of the router

    def __init__(self, name):
        r"""!Create a new router
 
        @param name: name of the router"""
        self.name = name
        self.routeList = []
 
        # for time counting
        self._cumTime = 0
        self._routerTime = 0
 
        # for statistics
        self._runCount = 0
 
        logging.debug("[%s] add new router", self.name)
 

Member Function Documentation

addRoute()

boswatch.router.router.Router.addRoute	(		self,
			route
	)

Adds a route point to the router.

Parameters

route

instance of the Route class

    def addRoute(self, route):
        r"""!Adds a route point to the router
 
        @param route: instance of the Route class
        """
        logging.debug("[%s] add route: %s", self.name, route.name)
        self.routeList.append(route)
 

runRouter()

boswatch.router.router.Router.runRouter	(		self,
			bwPacket
	)

Run the router.

Parameters

bwPacket

instance of Packet class

Returns

an instance of Packet class, a list of packets, or False

    def runRouter(self, bwPacket):
        r"""!Run the router
 
        @param bwPacket: instance of Packet class
        @return an instance of Packet class, a list of packets, or False
        """
        self._runCount += 1
        tmpTime = time.time()
 
        logging.debug("[%s] started", self.name)
 
        # Start processing the route list recursively from index 0
        final_result = self._process_route_recursive(bwPacket, 0)
 
        logging.debug("[%s] finished", self.name)
 
        self._routerTime = time.time() - tmpTime
        self._cumTime += self._routerTime
 
        return final_result
 

_process_route_recursive()

boswatch.router.router.Router._process_route_recursive (   self,   bwPacket,   start_index  )

protected

Recursively process the route to support list branching (e.g.

for multicast)

Parameters

bwPacket	current packet to process
start_index	index of the routeList to start from

Returns

processed bwPacket, list of packets, or False

    def _process_route_recursive(self, bwPacket, start_index):
        r"""!Recursively process the route to support list branching (e.g. for multicast)
 
        @param bwPacket: current packet to process
        @param start_index: index of the routeList to start from
        @return processed bwPacket, list of packets, or False
        """
        # Catch incoming lists from the manager (cascaded routers)
        if isinstance(bwPacket, list):
            logging.debug("[%s] Received a list of %d packets from manager. Branching immediately.", self.name, len(bwPacket))
            results = []
            for single_packet in bwPacket:
                res = self._process_route_recursive(single_packet, start_index)
                if res is not False and res is not None:
                    if isinstance(res, list):
                        results.extend(res)
                    else:
                        results.append(res)
            return results if results else False
 
        # Normal path for a single packet starts here
        current_packet = bwPacket
 
        for i in range(start_index, len(self.routeList)):
            routeObject = self.routeList[i]
            logging.debug("[%s] -> run route: %s", self.name, routeObject.name)
 
            # State Isolation: pass a deep copy to prevent plugins from corrupting the RAM state of subsequent list items
            bwPacket_tmp = routeObject.callback(copy.deepcopy(current_packet))
 
            if bwPacket_tmp is None:
                # returning None doesnt change the current_packet
                continue
 
            if bwPacket_tmp is False:
                if routeObject.isRouter:
                    # A nested router filtered/stopped internally for this packet.
                    # That's just an empty branch - the parent router continues normally.
                    logging.debug("[%s] sub-router '%s' returned False - continuing with next route point", self.name, routeObject.name)
                    continue
 
                # returning False stops the route immediately for this specific packet branch
                logging.debug("[%s] stopped at route %s", self.name, routeObject.name)
                return False
 
            if isinstance(bwPacket_tmp, list):
                # Branching logic: A module returned a list of packets
                logging.debug("[%s] route %s returned a list. Branching for %d packets.", self.name, routeObject.name, len(bwPacket_tmp))
                results = []
 
                for single_packet in bwPacket_tmp:
                    # Recursively process the rest of the route (starting at next index) for each packet
                    res = self._process_route_recursive(single_packet, i + 1)
 
                    # Aggregate results
                    if res is not False and res is not None:
                        if isinstance(res, list):
                            results.extend(res)
                        else:
                            results.append(res)
 
                # The recursive calls already finished the rest of the route for all branches.
                # We return the aggregated results immediately to break out of this current loop level.
                return results if results else False
 
            # Normal single packet path: update the packet for the next iteration
            current_packet = bwPacket_tmp
 
        return current_packet
 

_getStatistics()

boswatch.router.router.Router._getStatistics (   self )

protected

Returns statistical information's from last router run.

Returns

Statistics as pyton dict

    def _getStatistics(self):
        r"""!Returns statistical information's from last router run
 
        @return Statistics as pyton dict"""
        stats = {"type": "router",
                 "runCount": self._runCount,
                 "cumTime": self._cumTime,
                 "moduleTime": self._routerTime}
        return stats

Field Documentation

name

boswatch.router.router.Router.name

routeList

boswatch.router.router.Router.routeList

_cumTime

boswatch.router.router.Router._cumTime

protected

_routerTime

boswatch.router.router.Router._routerTime

protected

_runCount

boswatch.router.router.Router._runCount

protected