xaal.lib 0.7.2__py3-none-any.whl

xaal/lib/config.py

@@ -0,0 +1,53 @@
+
+# Default configuration
+import os
+import sys
+import binascii
+from configobj import ConfigObj
+
+self = sys.modules[__name__]
+
+# Default settings
+DEF_ADDR = '224.0.29.200'       # mcast address
+DEF_PORT = 1236                 # mcast port
+DEF_HOPS = 10                   # mcast hop
+DEF_ALIVE_TIMER = 100           # Time between two alive msg
+DEF_CIPHER_WINDOW = 60 * 2      # Time Window in seconds to avoid replay attacks
+DEF_QUEUE_SIZE = 10             # How many packet we can send in one loop
+DEF_LOG_LEVEL = 'DEBUG'         # should be INFO|DEBUG|None
+DEF_LOG_PATH  = '/var/log/xaal' # where log are 
+
+# TBD : Move this stuff
+STACK_VERSION = 7
+
+
+if 'XAAL_CONF_DIR' in os.environ:
+    self.conf_dir = os.environ['XAAL_CONF_DIR']
+else:
+    self.conf_dir = os.path.expanduser("~") + '/.xaal'
+
+
+def load_config(name='xaal.ini'):
+    filename = os.path.join(self.conf_dir, name)
+    if not os.path.isfile(filename):
+        print("Unable to load xAAL config file [%s]" % filename)
+        sys.exit(-1)
+
+    cfg = ConfigObj(filename)
+    self.address       = cfg.get('address',DEF_ADDR)
+    self.port          = int(cfg.get('port',DEF_PORT))
+    self.hops          = int(cfg.get('hops',DEF_HOPS))
+    self.alive_timer   = int(cfg.get('alive_timer',DEF_ALIVE_TIMER))
+    self.cipher_window = int(cfg.get('ciper_window',DEF_CIPHER_WINDOW))
+    self.queue_size    = int(cfg.get('queue_size',DEF_QUEUE_SIZE))
+    self.log_level     = cfg.get('log_level',DEF_LOG_LEVEL)
+    self.log_path      = cfg.get('log_path',DEF_LOG_PATH)
+    key = cfg.get('key',None)
+
+    if key:
+        self.key = binascii.unhexlify(key.encode('utf-8'))
+    else:
+        print("Please set key in config file [%s]" % filename)
+        self.key = None
+
+load_config()

xaal/lib/core.py

@@ -0,0 +1,308 @@
+#
+#  Copyright 2014, Jérôme Colin, Jérôme Kerdreux, Philippe Tanguy,
+#  Telecom Bretagne.
+#
+#  This file is part of xAAL.
+#
+#  xAAL is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  xAAL is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with xAAL. If not, see <http://www.gnu.org/licenses/>.
+#
+
+from .messages import MessageType, MessageAction, MessageFactory, ALIVE_ADDR
+from .exceptions  import *
+
+import time
+import inspect
+
+import logging
+logger = logging.getLogger(__name__)
+
+class EngineMixin(object):
+
+    __slots__ = ['devices','timers','subscribers','msg_filter','_attributesChange','network','msg_factory']
+
+    def __init__(self,address,port,hops,key):
+        self.devices = []                        # list of devices / use (un)register_devices()
+        self.timers = []                         # functions to call periodic
+        self.subscribers = []                    # message receive workflow
+        self.msg_filter = None                  # message filter
+
+        self._attributesChange = []              # list of XAALAttributes instances
+
+        # network connector
+        self.network = None
+        # start msg worker
+        self.msg_factory = MessageFactory(key)
+        # filter function activated
+        self.enable_msg_filter()
+
+    #####################################################
+    # Devices management
+    #####################################################
+    def add_device(self, dev):
+        """register a new device """
+        if dev not in self.devices:
+            self.devices.append(dev)
+            dev.engine = self
+        if self.is_running():
+            self.send_alive(dev)
+
+    def add_devices(self, devs):
+        """register new devices"""
+        for dev in devs:
+            self.add_device(dev)
+
+    def remove_device(self, dev):
+        """unregister a device """
+        dev.engine = None
+        # Remove dev from devices list
+        self.devices.remove(dev)
+
+    #####################################################
+    # xAAL messages Tx handling
+    #####################################################
+    # Fifo for msg to send
+    def queue_msg(self, msg):
+        logger.critical("To be implemented queue_msg: %s", msg)
+
+    def send_request(self,dev,targets,action,body = None):
+        """queue a new request"""
+        msg = self.msg_factory.build_msg(dev, targets, MessageType.REQUEST, action, body)
+        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, MessageType.REPLY, action, body)
+        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_msg(msg)
+
+    def send_get_description(self, dev, targets):
+        """queue a get_description request"""
+        self.send_request(dev, targets, MessageAction.GET_DESCRIPTION.value)
+
+    def send_get_attributes(self, dev, targets):
+        """queue a get_attributes request"""
+        self.send_request(dev, targets, MessageAction.GET_ATTRIBUTES.value)
+
+    def send_notification(self, dev, action, body=None):
+        """queue a notificaton"""
+        msg = self.msg_factory.build_msg(dev, [], MessageType.NOTIFY, action,body)
+        self.queue_msg(msg)
+
+    def send_alive(self, dev):
+        """Send a Alive message for a given device"""
+        timeout = dev.get_timeout()
+        msg = self.msg_factory.build_alive_for(dev, timeout)
+        self.queue_msg(msg)
+        dev.update_alive()
+
+    def send_is_alive(self, dev, targets=[ALIVE_ADDR,], dev_types=["any.any",]):
+        """Send a is_alive message, w/ dev_types filtering"""
+        body = {'dev_types': dev_types}
+        self.send_request(dev,targets, MessageAction.IS_ALIVE.value, body)
+
+
+    #####################################################
+    # Messages filtering
+    #####################################################
+    def enable_msg_filter(self, func=None):
+        """enable message filter"""
+        self.msg_filter = func or self.default_msg_filter
+
+    def disable_msg_filter(self):
+        """disable message filter"""
+        self.msg_filter = None
+
+    def default_msg_filter(self, msg):
+        """
+        Filter messages:
+        - check if message has alive request address
+        - check if the message is for us
+        return False, if message should be dropped
+        """
+        # Alive request
+        if ALIVE_ADDR in msg.targets:
+            return True
+        # Managed device ?
+        for dev in self.devices:
+            if dev.address in msg.targets:
+                return True
+        return False
+
+    #####################################################
+    # Alive messages
+    #####################################################
+    def process_alives(self):
+        """Periodic sending alive messages"""
+        now = time.time()
+        for dev in self.devices:
+            if dev.next_alive < now :
+                self.send_alive(dev)
+
+    #####################################################
+    # xAAL attributes changes
+    #####################################################
+    def add_attributes_change(self, attr):
+        """add a new attribute change to the list"""
+        self._attributesChange.append(attr)
+
+    def get_attributes_change(self):
+        """return the pending attributes changes list"""
+        return self._attributesChange
+
+    def process_attributes_change(self):
+        """Processes (send notify) attributes changes for all devices"""
+        devices = {}
+        # Group attributes changed by device
+        for attr in self.get_attributes_change():
+            if attr.device not in devices.keys():
+                devices[attr.device] = {}
+            devices[attr.device][attr.name] = attr.value
+
+        for dev in devices:
+            self.send_notification(dev, MessageAction.ATTRIBUTES_CHANGE.value, devices[dev])
+        self._attributesChange = []  # empty array
+
+    #####################################################
+    # xAAL messages subscribers
+    #####################################################
+    def subscribe(self,func):
+        self.subscribers.append(func)
+
+    def unsubscribe(self,func):
+        self.subscribers.remove(func)
+
+    #####################################################
+    # timers
+    #####################################################
+    def add_timer(self, func, period,counter=-1):
+        """ 
+        func: function to call
+        period: period in second
+        counter: number of repeat, -1 => always
+        """
+        if counter == 0:
+            raise EngineError("Timer counter should =-1 or >0")
+        t = Timer(func, period, counter)
+        self.timers.append(t)
+        return t
+
+    def remove_timer(self, timer):
+        """remove a given timer from the list"""
+        self.timers.remove(timer)
+
+    #####################################################
+    # start/stop/run API
+    #####################################################
+    def start(self):
+        logger.critical("To be implemented start")
+
+    def stop(self):
+        logger.critical("To be implemented stop")
+
+    def shutdown(self):
+        logger.critical("To be implemented shutdown")
+
+    def run(self):
+        logger.critical("To be implemented run")
+
+    def is_running(self):
+        logger.critical("To be implemented is_running")
+
+#####################################################
+# Timer class
+#####################################################
+class Timer(object):
+    def __init__(self, func, period, counter):
+        self.func = func
+        self.period = period
+        self.counter = counter
+        self.deadline = time.time() + period
+
+#####################################################
+# Usefull functions to Engine developpers
+#####################################################
+def filter_msg_for_devices(msg, devices):
+    """
+    loop throught the devices, to find which are expected w/ the msg
+    - Filter on dev_types for is_alive broadcast request.
+    - Filter on device address
+    """
+    results = []
+    if msg.is_request_isalive() and (ALIVE_ADDR in msg.targets):
+        # if we receive a broadcast is_alive request, we reply
+        # with filtering on dev_tyes. 
+        if 'dev_types' in msg.body.keys():
+            dev_types = msg.body['dev_types']
+            if 'any.any' in dev_types:
+                results = devices
+            else:
+                for dev in devices:
+                    any_subtype = dev.dev_type.split('.')[0] + '.any'
+                    if dev.dev_type in dev_types:
+                        results.append(dev)
+                    elif any_subtype in dev_types:
+                        results.append(dev)
+    else:
+        # this is a normal request, only filter on device address
+        # note: direct is_alive are treated like normal request 
+        # so dev_types filtering is discarded
+        for dev in devices:
+            if dev.address in msg.targets:
+                results.append(dev)
+    return results
+
+def search_action(msg, device):
+    """
+    Extract an action (match with methods) from a msg on the device.
+    Return:
+        - None
+        - found method & matching parameters
+
+    Note: If method not found raise error, if wrong parameter error log
+    """
+    methods = device.get_methods()
+    params = {}
+    result = None
+    if msg.action in methods.keys():
+        method = methods[msg.action]
+        body_params = None
+        if msg.body:
+            method_params = get_args_method(method)
+            body_params = msg.body
+
+            for k in body_params:
+                temp = '_%s' %k
+                if temp in method_params:
+                    params.update({temp:body_params[k]})
+                else:
+                    logger.warning("Wrong method parameter [%s] for action %s" %(k, msg.action))
+        result =  (method,params)
+    else:
+        raise XAALError("Method %s not found on device %s" % (msg.action,device))
+    return result
+
+def get_args_method(method):
+    """ return the list on arguments for a given python method """
+    spec = inspect.getfullargspec(method)
+    try:
+        spec.args.remove('self')
+    except Exception:
+        pass
+    return spec.args
+
+

xaal/lib/devices.py

@@ -0,0 +1,285 @@
+#
+#  Copyright 2014, Jérôme Colin, Jérôme Kerdreux, Philippe Tanguy,
+#  Telecom Bretagne.
+#
+#  This file is part of xAAL.
+#
+#  xAAL is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  xAAL is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with xAAL. If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+from . import config
+from . import tools
+from . import bindings
+from .exceptions import DeviceError
+
+from tabulate import tabulate
+import logging
+logger = logging.getLogger(__name__)
+
+import time
+
+class Attribute(object):
+
+    def __init__(self, name, dev=None, default=None):
+        self.name = name
+        self.default = default
+        self.device = dev
+        self.__value = default
+
+    @property
+    def value(self):
+        return self.__value
+
+    @value.setter
+    def value(self, value):
+        if value != self.__value:
+            eng = self.device.engine
+            if eng:
+                eng.add_attributes_change(self)
+                logger.debug("Attr change %s %s=%s" % (self.device.address,self.name,value))
+        self.__value = value
+
+    def __repr__(self): # pragma: no cover
+        return f"<{self.__module__}.Attribute {self.name} at 0x{id(self):x}>"
+    
+
+class Attributes(list):
+    """Devices owns a attributes list. This list also have dict-like access"""
+
+    def __getitem__(self,value):
+        if isinstance(value,int):
+            return list.__getitem__(self,value)
+        for k in self:
+            if (value == k.name):
+                return k.value
+        raise KeyError(value)
+    
+    def __setitem__(self,name,value):
+        if isinstance(name,int):
+            return list.__setitem__(self,name,value)
+        for k in self:
+            if (name == k.name):
+                k.value = value
+                return
+        raise KeyError(name)
+    
+class Device(object):
+
+    __slots__ = ['__dev_type','__address','group_id',
+                'vendor_id','product_id','hw_id',
+                '__version','__url','schema','info',
+                'unsupported_attributes','unsupported_methods','unsupported_notifications',
+                'alive_period','next_alive',
+                '__attributes','methods','engine']
+
+    def __init__(self,dev_type,addr=None,engine=None):
+        # xAAL internal attributes for a device
+        self.dev_type = dev_type        # xaal dev_type
+        self.address = addr             # xaal addr
+        self.group_id = None            # group devices
+        self.vendor_id = None           # vendor ID ie : ACME
+        self.product_id = None          # product ID
+        self.hw_id = None               # hardware info
+        self.__version = None           # product release
+        self.__url = None               # product URL
+        self.schema = None              # schema URL
+        self.info = None                # additionnal info
+        
+        # Unsupported stuffs
+        self.unsupported_attributes = []
+        self.unsupported_methods = []
+        self.unsupported_notifications = []
+        # Alive management
+        self.alive_period = config.alive_timer # time in sec between two alive
+        self.next_alive = 0
+        # Default attributes & methods
+        self.__attributes = Attributes()
+        self.methods = {'get_attributes' : self._get_attributes,
+                        'get_description': self._get_description }
+        self.engine = engine
+
+    @property
+    def dev_type(self):
+        return self.__dev_type
+
+    @dev_type.setter
+    def dev_type(self, value):
+        if not tools.is_valid_dev_type(value):
+            raise DeviceError(f"The dev_type {value} is not valid")
+        self.__dev_type = value
+
+    @property
+    def version(self):
+        return self.__version
+
+    @version.setter
+    def version(self, value):
+        # version must be a string
+        if value:
+            self.__version = "%s" % value
+        else:
+            self.__version = None
+
+    @property
+    def address(self):
+        return self.__address
+
+    @address.setter
+    def address(self, value):
+        if value == None:
+            self.__address = None
+            return
+        if not tools.is_valid_address(value):
+            raise DeviceError("This address is not valid")
+        self.__address = value
+
+    @property
+    def url(self):
+        return self.__url
+
+    @url.setter
+    def url(self,value):
+        if value == None:
+            self.__url = None
+        else:
+            self.__url = bindings.URL(value)
+
+    # attributes
+    def new_attribute(self,name,default=None):
+        attr = Attribute(name,self,default)
+        self.add_attribute(attr)
+        return attr
+
+    def add_attribute(self, attr):
+        if attr:
+            self.__attributes.append(attr)
+            attr.device = self
+    
+    def del_attribute(self,attr):
+        if attr:
+            attr.device = None
+            self.__attributes.remove(attr)
+
+    def get_attribute(self,name):
+        for attr in self.__attributes:
+            if attr.name == name:
+                return attr
+        return None
+
+    @property
+    def attributes(self):
+        return self.__attributes
+
+    @attributes.setter
+    def attributes(self,values):
+        if isinstance(values,Attributes):
+            self.__attributes = values
+        else:
+            raise DeviceError("Invalid attributes list, use class Attributes)")
+
+    def add_method(self,name,func):
+        self.methods.update({name:func})
+
+    def get_methods(self):
+        return self.methods
+
+    def update_alive(self):
+        """ update the alive timimg"""
+        self.next_alive = time.time() + self.alive_period
+
+    def get_timeout(self):
+        """ return Alive timeout used for isAlive msg"""
+        return 2 * self.alive_period
+
+    #####################################################
+    # Usefull methods
+    #####################################################
+    def dump(self):
+        print("= Device: %s" % self)
+        # info & description
+        r = []
+        r.append(['dev_type',self.dev_type])
+        r.append(['address',self.address])
+        for k,v in self._get_description().items():
+            r.append([k,v])
+        print(tabulate(r,tablefmt="fancy_grid"))
+        
+        # attributes
+        if len(self._get_attributes()) > 0:
+            r = []
+            for k,v in self._get_attributes().items():
+                r.append([k,str(v)])
+            print(tabulate(r,tablefmt="fancy_grid"))
+
+        # methods
+        if len(self.methods) > 0:
+            r = []
+            for k,v in self.methods.items():
+                r.append([k,v.__name__])
+            print(tabulate(r,tablefmt="fancy_grid"))
+
+
+    def __repr__(self):
+        return f"<xaal.Device {id(self):x} {self.address} {self.dev_type}>"
+
+    #####################################################
+    # default public methods
+    #####################################################
+    def _get_description(self):
+        result = {}
+        if self.vendor_id:  result['vendor_id']  = self.vendor_id
+        if self.product_id: result['product_id'] = self.product_id
+        if self.version:    result['version']    = self.version
+        if self.url:        result['url']        = self.url
+        if self.schema:     result['schema']     = self.schema
+        if self.info:       result['info']       = self.info
+        if self.hw_id:      result['hw_id']      = self.hw_id
+        if self.group_id:   result['group_id']   = self.group_id
+        if self.unsupported_methods:       result['unsupported_methods']       = self.unsupported_methods
+        if self.unsupported_notifications: result['unsupported_notifications'] = self.unsupported_notifications
+        if self.unsupported_attributes:    result['unsupported_attributes']    = self.unsupported_attributes
+        return result
+
+    def _get_attributes(self, _attributes=None):
+        """
+        attributes:
+            - None = body empty and means request all attributes
+            - Empty array means request all attributes
+            - Array of attributes (string) and means request attributes in the
+              list
+
+        TODO: (Waiting for spec. decision) add test on attribute devices
+            - case physical sensor not responding or value not ready add error
+            with specific error code and with value = suspicious/stale/cached
+        """
+        result = {}
+        dev_attr = {attr.name: attr for attr in self.__attributes}
+        if _attributes:
+            # Process attributes filter
+            for attr in _attributes:
+                if attr in dev_attr.keys():
+                    result.update({dev_attr[attr].name: dev_attr[attr].value})
+                else:
+                    logger.debug(f"Attribute {attr} not found")
+        else:
+            # Process all attributes
+            for attr in dev_attr.values():
+                result.update({attr.name: attr.value})
+        return result
+
+    def send_notification(self,notification,body={}):
+        """ queue an notification, this is just a method helper """
+        if self.engine:
+            self.engine.send_notification(self,notification,body)