Remove the rx_handler attribute for something more pythonic

git-svn-id: https://redmine.imt-atlantique.fr/svn/xaal/code/Python/branches/fork@1776 b32b6428-25c9-4566-ad07-03861ab6144f

apps/monitor/xaal/monitor/monitor.py

@@ -4,6 +4,8 @@ import time,random
 import logging
 logger = logging.getLogger(__name__)
 
+HIDDEN_ATTRIBUTES = ['busAddr','busPort','hops']
+
 class Device:
     def __init__(self, addr, devtype, version):
         self.address = addr
@@ -19,14 +21,18 @@ class Device:
 
         print("Adding %s - %s" % (addr, devtype))
 
-    def update_attributes(self, value):
-        self.attributes.update(value)
-        if 'busAddr' in self.attributes.keys():
-            self.attributes.pop('busAddr')
-        if 'hops' in self.attributes.keys():
-            self.attributes.pop('hops')
-        if 'busPort' in self.attributes.keys():
-            self.attributes.pop('busPort')
+    def update_attributes(self, data):
+        """ rude update attributes. Return true if updated"""
+        keys = list(data.keys())
+        change = False
+        for k in keys:
+            if k in HIDDEN_ATTRIBUTES:
+                data.pop(k)
+        # really no the best comparaison, but we just need a flag
+        if self.attributes == data:
+            return False
+        self.attributes.update(data)
+        return True
 
     def update_description(self, value):
         self.description.update(value)
@@ -133,40 +139,32 @@ class Monitor:
     def __init__(self,device,filter_func=None):
         self.dev = device
         self.eng = device.engine
-        self.eng.handle_rx_msg = self.msg_dispatch
+
         self.devices = Devices()
         self.filter = filter_func
         self.subscribers = []
+        self.eng.add_rx_handler(self.parse_msg)
         self.eng.add_timer(self.auto_wash, 10)
         self.eng.add_timer(self.send_isalive, 180)
         self.eng.add_timer(self.refresh_devices, 5)
 
 
-    def msg_dispatch(self,msg):
-        if (self.filter==None) or self.filter(msg):
-            self._msg_dispatch(msg)
-        
-        # let's engine do the jobs for use
-        self.eng.handle_request(msg)
+    def parse_msg(self, msg):
+        # do nothing for some msg
+        if (self.filter!=None) and self.filter(msg)==False:
+            return
 
-    def _msg_dispatch(self, msg):
-        new_dev = False
         if msg.source not in self.devices:
             self.add_device(msg)
-            new_dev = True
 
         dev = self.devices.get_with_addr(msg.source)
 
         if msg.is_alive():
             dev.alive(msg.body['timeout'])
 
-        elif msg.is_attributes_change():
-            dev.update_attributes(msg.body)
-            self.notify('ATTRIBUTE_CHANGE',dev)
-
-        elif msg.is_get_attribute_reply():
-            dev.update_attributes(msg.body)
-            if new_dev:
+        elif msg.is_attributes_change() or msg.is_get_attribute_reply():
+            r = dev.update_attributes(msg.body)
+            if r:
                 self.notify('ATTRIBUTE_CHANGE',dev)
 
         elif msg.is_get_description_reply():

apps/tools/xaal/tools/dumper.py

@@ -29,7 +29,7 @@ def display(msg):
 def main():
     try:
         eng = Engine()
-        eng.handle_rx_msg = display
+        eng.add_rx_handler(display)
         eng.run()
     except KeyboardInterrupt:
         print("Bye Bye")

apps/tools/xaal/tools/info.py

@@ -34,11 +34,11 @@ class InfoDumper:
 
     def __init__(self,engine):
         self.eng = engine
-        self.eng.handle_rx_msg = self.parse_answer
         # new fake device
         self.addr = tools.get_random_uuid()
         self.dev = Device("cli.experimental",self.addr)
         self.eng.add_device(self.dev)
+        self.eng.add_rx_handler(self.parse_answer)
         print("xAAL Info dumper [%s]" % self.addr)
 
 

apps/tools/xaal/tools/isalive.py

@@ -27,11 +27,11 @@ class Scanner:
 
     def __init__(self,engine):
         self.eng = engine
-        self.eng.handle_rx_msg = self.parse_answer
         # new fake device
         self.addr = tools.get_random_uuid()
         self.dev = Device("cli.experimental",self.addr)
         self.eng.add_device(self.dev)
+        self.eng.add_rx_handler(self.parse_answer)
 
     def query(self,devtype):
         self.devtype = devtype

apps/tools/xaal/tools/querydb.py

@@ -34,11 +34,11 @@ class QueryDB:
 
     def __init__(self,engine):
         self.eng = engine
-        self.eng.handle_rx_msg = self.parse_answer
         # new fake device
         self.addr = tools.get_random_uuid()
         self.dev = Device("cli.experimental",self.addr)
         self.eng.add_device(self.dev)
+        self.eng.add_rx_handler(self.parse_answer)
         print("xAAL Info dumper [%s]" % self.addr)
 
 

apps/tools/xaal/tools/tail.py

@@ -73,7 +73,7 @@ def main():
         level = int(sys.argv[1])
 
         eng = Engine()
-        eng.handle_rx_msg = display
+        eng.add_rx_handler(display)
 
         eng.start()
         term('@@')

lib/xaal/lib/core.py

@@ -48,7 +48,8 @@ class Engine(object):
         self.__attributesChange = []             # list of XAALAttributes instances
         self.__txFifo = collections.deque()      # tx msg fifo
         self.__alives = []                       # list of alive devices
-        self.handle_rx_msg = self.handle_request # default rx flow
+        self.rx_handlers =[self.handle_request]  # by default
+
 
         # start network
         self.network = NetworkConnector(address, port, hops)
@@ -80,7 +81,7 @@ class Engine(object):
     # xAAL messages Tx handling
     #####################################################
     # Fifo for msg to send
-    def queue_tx(self, msg):
+    def queue_msg(self, msg):
         """queue a message"""
         self.__txFifo.append(msg)
 
@@ -91,22 +92,23 @@ class Engine(object):
             self.send_msg(temp)
 
     def send_msg(self, msg):
+        """Send an message to the bus, use queue_msg instead"""
         self.network.send(msg)
 
     def send_request(self,dev,targets,action,body = None):
         """queue a new request"""
         msg = self.msg_factory.build_msg(dev, targets, 'request', action, body)
-        self.queue_tx(msg)
+        self.queue_msg(msg)
 
     def send_reply(self, dev, targets, action, body=None):
         """queue a new reply"""
         msg = self.msg_factory.build_msg(dev, targets, 'reply', action, body)
-        self.queue_tx(msg)
+        self.queue_msg(msg)
 
     def send_error(self, dev, errcode, description=None):
         """queue a error message"""
         msg = self.msg_factory.build_error_msg(dev, errcode, description)
-        self.queue_tx(msg)
+        self.queue_msg(msg)
 
     def send_get_description(self,dev,targets):
         """queue a getDescription request"""
@@ -123,14 +125,14 @@ class Engine(object):
         """Send a Alive message for a given device"""
         timeout = dev.get_timeout()
         msg = self.msg_factory.build_alive_for(dev, timeout)
-        self.queue_tx(msg)
+        self.queue_msg(msg)
 
     def send_isAlive(self, dev, devtypes):
         """Send a isAlive message, w/ devTypes filtering"""
         body = {}
         body['devTypes'] = devtypes
         msg = self.msg_factory.build_msg(dev, [], "request", "isAlive", body)
-        self.queue_tx(msg)
+        self.queue_msg(msg)
 
     def process_alives(self):
         """Periodic sending alive messages"""
@@ -165,7 +167,7 @@ class Engine(object):
 
         for dev in devices:
             msg = self.msg_factory.build_msg(dev, [], "notify", "attributesChange", devices[dev])
-            self.queue_tx(msg)
+            self.queue_msg(msg)
 
         self.__attributesChange = []  # empty array
 
@@ -185,11 +187,18 @@ class Engine(object):
             result = msg
         return result
 
+    def add_rx_handler(self,func):
+        self.rx_handlers.append(func)
+
+    def remove_rx_hanlder(self,func):
+        self.rx_handlers.remove(func)
+
     def process_rx_msg(self):
         """process incomming messages"""
         msg = self.receive_msg()
         if msg:
-            self.handle_rx_msg(msg)
+            for func in self.rx_handlers:
+                func(msg)
 
     def handle_request(self, msg):
         """Filter msg for devices according default xAAL API then process the