benchlab-pytools 3.0.0__py3-none-any.whl

benchlab/vu/VU-Server/server_config.py

@@ -0,0 +1,255 @@
+# pylint: disable=E1101
+import os
+from ruamel.yaml import YAML
+# import yaml
+from dials.base_logger import logger
+from vu_notifications import show_error_msg, show_warning_msg
+import database as db
+
+class ServerConfig:
+    config_path = None
+    server = None
+    hardware = None
+    server_default = {'hostname': 'localhost', 'port': 3000, 'communication_timeout': 10, 'master_key': 'cTpAWYuRpA2zx75Yh961Cg' }
+    hardware_default = {'port': None }
+    dials = {}
+    api_keys = {}
+    database = None
+
+    def __init__(self, config_file='config.yaml'):
+        self.config_path =  os.path.join(os.path.dirname(__file__), config_file)
+        logger.info(f"VU1 config yaml file: {self.config_path}")
+        self.database = db.DialsDB(init_if_missing=True)
+        self._load_config()     # Load configuration from .yaml file
+        self._load_API_keys()   # Load API keys from `api_keys` section
+        self.debug_config()
+
+    # Save current configuration to .yaml file
+    def _save_config(self):
+        config = None
+        yaml = YAML(typ='safe', pure=True)
+
+        if os.path.exists(self.config_path):
+            with open(self.config_path, 'r', encoding="utf-8") as file:
+                config = yaml.load(file) # pylint: disable=assignment-from-no-return
+
+        if not config:
+            config = {}
+
+        # Update server config
+        if not config.get('server'):
+            config['server'] = self.server
+            config['port'] = self.server['port']
+            config['communication_timeout'] = 5000
+        else:
+            config['server']['hostname'] = self.server['hostname']
+            config['server']['port'] = self.server['port']
+            config['server']['communication_timeout'] = self.server['communication_timeout']
+
+        with open(self.config_path, 'w', encoding="utf-8") as file:
+            yaml.dump(config, file)
+
+    # Read .yaml config file
+    def _load_config(self):
+        if not os.path.exists(self.config_path):
+            logger.error(f"Can not load config. Config file '{self.config_path}' does not exist!")
+            show_error_msg("Can not find config.yaml", f"Config file '{self.config_path}' is missing!\r\n"\
+                           "Please fix this issue by creating a default config.yaml file in the VU Server directory.\r\n"\
+                           "Using default values for this session.")
+            self._create_default_config()
+            return False
+
+        yaml = YAML(typ='safe', pure=True)
+        with open(self.config_path, 'r', encoding="utf-8") as file:
+            cfg = yaml.load(file)  # pylint: disable=assignment-from-no-return
+
+        if cfg is None:
+            show_error_msg("Empty/corrupt config file!", "Config file exists but it is empty or corrupt!\r\n"\
+                           "Using defaul values for this session.")
+            self._create_default_config()
+            return False
+
+        # Check that config file meets the minimum requirements
+        if not isinstance(cfg, dict) or 'server' not in cfg or 'hardware' not in cfg:
+            show_warning_msg("Missing Key", f"Config file '{self.config_path}' \r\n"\
+                             "Must have valid entries for 'server' and 'hardware' configuration!\r\n"\
+                             "Using defaul values for this session.")
+            cfg = {}
+            cfg['server'] = self.server_default
+            cfg['hardware'] = self.hardware_default
+
+        elif not isinstance(cfg['server'], dict):
+            show_warning_msg("Invalid server config", f"Config file '{self.config_path}' \r\n"\
+                             "Has invalid `server` config entry.\r\n"\
+                             "Using defaul values for this session.")
+            self._force_default_config()
+            return False
+
+        elif not isinstance(cfg['hardware'], dict):
+            show_warning_msg("Invalid server config", f"Config file '{self.config_path}' \r\n"\
+                             "Has invalid `hardware` config entry.\r\n"\
+                             "Using defaul values for this session.")
+            self._force_default_config()
+            return False
+
+        elif ('hostname' not in cfg['server'] or
+             'port' not in cfg['server'] or
+             'communication_timeout' not in cfg['server'] or
+             'master_key' not in cfg['server']):
+            show_warning_msg("Missing Key", f"Config file '{self.config_path}' \r\n"\
+                             "must have `hostname`, `port`, `communication_timeout` and `master_key` entries!\r\n"\
+                             "Using defaul values for this session.")
+            self._force_default_config()
+            return False
+
+        elif 'port' not in cfg['hardware']:
+            show_warning_msg("Missing Key", f"Config file '{self.config_path}' \r\n"\
+                             "must have hardware `port` entry! (it can be left empty)\r\n"\
+                             "Using defaul values for this session.")
+            self._force_default_config()
+            return False
+
+        # Load yaml values
+        self.server = cfg.get('server', self.server_default)
+        self.hardware = cfg.get('hardware', self.hardware_default)
+
+        return True
+
+    def _force_default_config(self):
+        self.server = self.server_default
+        self.hardware = self.hardware_default
+
+    def _create_default_config(self):
+        logger.info("Using default config values")
+        self.server = self.server_default
+        self.hardware = self.hardware_default
+
+    # Load API keys from config file
+    def _load_API_keys(self):
+        # Make sure .yaml master key exists in the database
+        self.database.api_update_master(self.server['master_key'])
+
+        # Load all API keys from the database
+        self.api_keys = self.database.api_key_list()
+
+    def reload_API_keys(self):
+        # Load all API keys from the database
+        self.api_keys = self.database.api_key_list()
+
+    def update_dial_db_cell(self, dial_uid, cell, value):
+        try:
+            ret = self.database.dial_update_cell(dial_uid=dial_uid, cell=cell, value=value)
+            if ret:
+                self.dials[dial_uid][cell] = value
+                return True
+            return False
+        except Exception as e:
+            logger.error(e)
+            return False
+
+    def update_dial_db_cell_with_dict(self, dial_uid, values_dict):
+        try:
+            self.database.dial_update_cell_with_dict(dial_uid=dial_uid, values_dict=values_dict)
+        except Exception as e:
+            logger.error(e)
+            return
+
+    # Read dial information stored in the DB and append to existing list
+    def append_dial_info_from_db(self, dial_list):
+        for key, dial in enumerate(dial_list):
+            dial_info = self.database.fetch_dial_info_or_create_default(dial['uid'])
+
+            dial_list[key]['dial_name'] = dial_info['dial_name']
+            dial_list[key]['fw_hash'] = dial_info['dial_build_hash']
+            dial_list[key]['fw_version'] = dial_info['dial_fw_version']
+            dial_list[key]['hw_version'] = dial_info['dial_hw_version']
+            dial_list[key]['protocol_version'] = dial_info['dial_protocol_version']
+            dial_list[key]['easing']['dial_step'] = dial_info['easing_dial_step']
+            dial_list[key]['easing']['dial_period'] = dial_info['easing_dial_period']
+            dial_list[key]['easing']['backlight_step'] = dial_info['easing_backlight_step']
+            dial_list[key]['easing']['backlight_period'] = dial_info['easing_backlight_period']
+
+            self.dials[dial['uid']] = dial
+
+        return dial_list
+
+    def dial_fetch_db_info(self, dial_uid):
+        return self.database.fetch_dial_info_or_create_default(dial_uid)
+
+    # Print out .yaml config
+    def debug_config(self):
+        logger.debug(f"\t Host: {self.server['hostname']}")
+        logger.debug("--- Server Config ---")
+        logger.debug(f"\t Port: {self.server['port']}")
+        logger.debug(f"\t Serial Timeout: {self.server['communication_timeout']}")
+        logger.debug(f"\t Master Key: {self.server['master_key']}")
+
+        logger.debug("--- API Keys ---")
+        logger.debug(f"\t There are {len(self.api_keys)} API keys loaded")
+
+    def get_server_config(self):
+        return self.server
+
+    def get_hardware_config(self):
+        return self.hardware
+
+    def create_api_key(self, key_name, priviledges=0):
+        generated_key = self.database.api_key_generate(key_name=key_name, level=priviledges)
+        logger.info(f"Generated API key '{generated_key}' (key_name:'{key_name}', priviledges:'{priviledges}')")
+        self.list_keys(reload=True)
+        return generated_key
+
+    def update_api_key(self, key_uid, key_name):
+        # Update key
+        if not self.database.api_key_update(key_uid=key_uid, key_name=key_name):
+            return False
+        return True
+
+    def delete_api_key(self, key_uid):
+        if not self.database.api_key_delete(key_uid=key_uid):
+            return False
+        self.list_keys(reload=True)
+        return True
+
+    def list_keys(self, reload=False):
+        if reload:
+            self.api_keys = self.database.api_key_list()
+        return self.api_keys
+
+    def api_key_add_dial_access(self, key, dials):
+        res = self.database.api_key_add_dial_access(key, dials)
+        if res:
+            self.list_keys(reload=True)
+        return res
+
+    # Returns True if provided key is listed as master key
+    # Otherwise return False
+    def validate_admin_key(self, key):
+        if not self.is_valid_api_key(key):
+            logger.debug(f"API key `{key}` does not exist")
+            return False
+
+        if self.api_keys[key]['priviledges'] >= 99:
+            return True
+        logger.debug("Key exists but not admin key.")
+        return False
+
+
+    # Returns True if API key existis, otherwise returns False
+    def is_valid_api_key(self, key):
+        if key in self.api_keys.keys():
+            return True
+        return False
+
+    # Returns True if API key has access to dial UID, otherwise retrns False
+    def api_key_has_access_to_dial(self, key, dial):
+        if not self.is_valid_api_key(key):
+            return False
+
+        # Master key has wildcard access
+        if self.api_keys[key]['priviledges'] >= 99:
+            return True
+
+        if dial in self.api_keys[key]['dials']:
+            return True
+        return False

benchlab/vu/VU-Server/server_dial_handler.py

@@ -0,0 +1,334 @@
+import os
+from time import time, sleep
+from math import trunc
+from dials.base_logger import logger
+
+# ServerDialHandler Class
+# ---
+# This class handles all the requests coming from the server.
+# It stores update requests (value, backlight, image etc) that are coming from the server API calls.
+# It will also periodically update the dials
+# ---
+# 'periodic_dial_update' function is called periodically from the main server loop
+#
+class ServerDialHandler:
+    dials = {}
+    hub_info = {}
+    communication_timeout = 3
+
+    def __init__(self, dial_driver, server_config):
+        self.dial_driver = dial_driver
+        self.server_config = server_config
+
+        # Communication timeout
+        cfg = self.server_config.get_server_config()
+        self.communication_timeout = cfg.get('communication_timeout', 3)
+        logger.info(f"Communication timeout set to {self.communication_timeout} seconds")
+
+        logger.debug("Retrieving list of dials")
+        self._reload_dials(True)
+
+        logger.debug("Reconfiguring dials with stored behaviour")
+        self._send_db_config_to_dials()
+
+        logger.debug("Setting all dials percentage to 0")
+        self.dial_driver.set_all_dials_to(0)
+
+        logger.debug("Server dial handler up and running.")
+
+    def periodic_dial_update(self):
+        updated = 0
+        ret=0
+
+        ret = self._periodic_update_dial_values()
+        updated = updated + ret
+
+        ret = self._periodic_update_dial_backlight()
+        updated = updated + ret
+
+        ret = self._periodic_update_dial_images()
+        updated = updated + ret
+
+        if updated <=0:
+            self._periodic_keep_alive()
+
+    def _convert_to_int(self, value):
+        try:
+            if not isinstance(value, int):
+                value = trunc(int(float(value)))
+        except Exception as e:
+            logger.error(e)
+            logger.error("Failed to convert value `{value}`to int. Defaulting to 0")
+            value = 0
+
+        return value
+
+    def _reload_dials(self, rescan=False):
+        # Get dial list from the dial driver (actual list reported from the hub)
+        dials = self.dial_driver.get_dial_list(rescan)
+
+        if len(dials)<=0:
+            logger.error("No dials connected to the bus!")
+            return
+
+        # 1 - Inform config/db what is the list of dials that we currently see
+        # 2 - Update handler information with any information retrieved from the database
+        # dials = self.server_config.append_dial_info_from_db(dials)
+        self.server_config.append_dial_info_from_db(dials)
+
+        # Dial HUB uses indexes to address each dial. On the server side we use UID for flexibility
+        # and also so that we can uniquely identify each dial.
+        for dial in dials:
+            dial['value'] = 0
+            dial['backlight'] = {'red':0, 'green':0, 'blue':0, 'white':0 }
+            dial['image_file'] = self._check_upload_for_dial_image(dial['uid'])
+            dial['update_deadline'] = time()
+            dial['value_changed'] = False
+            dial['backlight_changed'] = True
+            dial['image_changed'] = False
+            self.dials[dial['uid']] = dial
+
+    def _send_db_config_to_dials(self):
+        for _, dial in self.dials.items():
+            dial_step = dial['easing']['dial_step']
+            dial_period = dial['easing']['dial_period']
+            backlight_step = dial['easing']['backlight_step']
+            backlight_period = dial['easing']['backlight_period']
+
+            logger.debug(f"Configuring dial `{dial['uid']}`")
+            logger.debug(f"\tDial:{dial_step}% per {dial_period}ms")
+            logger.debug(f"\tBacklight {backlight_step}% {backlight_period}ms")
+            self.dial_set_easing_dial(dial['uid'], step=dial_step, period=dial_period)
+            self.dial_set_easing_backlight(dial['uid'], step=backlight_step, period=backlight_period)
+
+    def _check_upload_for_dial_image(self, dial_uid):
+        filename = f'img_{dial_uid}'
+        filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'upload', filename)
+        if os.path.exists(filepath):
+            return filename
+
+        return 'img_blank'
+
+    # TODO: Update to send multiple/all dial values in one go instead one-by-one
+    def _periodic_update_dial_values(self):
+        updated = 0
+        for _, dial in self.dials.items():
+            if dial['value_changed']:
+                self.dial_driver.dial_single_set_percent(dial['index'], dial['value'])
+                dial['value_changed'] = False
+                dial['update_deadline'] = time() + self.communication_timeout
+                updated = updated+1
+        if updated>0:
+            logger.debug(f"Updated {updated} dial values.")
+        return updated
+
+    def _periodic_update_dial_backlight(self):
+        updated = 0
+        for _, dial in self.dials.items():
+            if dial['backlight_changed']:
+                self.dial_driver.dial_set_backlight(dial['index'],
+                                                    dial['backlight']['red'],
+                                                    dial['backlight']['green'],
+                                                    dial['backlight']['blue'],
+                                                    dial['backlight']['white']
+                                                    )
+                dial['backlight_changed'] = False
+                dial['update_deadline'] = time() + self.communication_timeout
+                updated = updated+1
+        if updated>0:
+            logger.debug(f"Updated {updated} dial backlight(s).")
+        return updated
+
+    def _periodic_update_dial_images(self):
+        updated = 0
+        for _, dial in self.dials.items():
+            if dial['image_changed']:
+                logger.debug("Updating images")
+                self.dial_driver.update_display(device=dial['index'], imageFile=dial['image_file'])
+                dial['update_deadline'] = time() + self.communication_timeout
+                dial['image_changed'] = False
+                updated = updated+1
+        return updated
+
+    def _periodic_keep_alive(self):
+        #FIXME!
+        return
+        # for _, dial in self.dials.items():
+            # if time() >= dial['update_deadline']:
+                # logger.info("Keeping communication alive")
+                # self.dial_driver.dial_send_keep_comm_alive(device=dial['index'])
+                # dial['image_changed'] = False
+
+    def _dial_exists(self, dial_uid):
+        return dial_uid in self.dials
+
+    def provision_dials(self, num_attempts = 3):
+        logger.debug(f"Provisioning new dials (with {num_attempts} attempts)")
+        for _ in range(num_attempts):
+            self.dial_driver.provision_dials()
+            sleep(0.2)
+        logger.debug("Retrieving list of dials")
+        self._reload_dials(True)
+
+    def get_dial_info(self, dial_uid=None):
+        if dial_uid is not None:
+            return self.dials.get(dial_uid, None)
+        return self.dials
+
+    def dial_set_percent(self, dial_uid, value):
+        if not self._dial_exists(dial_uid):
+            logger.error(f"Dial {dial_uid} does not exist in dial list.")
+            return False
+
+        value = self._convert_to_int(value)
+
+        # Check if already at value
+        if self.dials[dial_uid]['value'] == value:
+            logger.debug(f"Dial {dial_uid} already at {value}")
+            return True
+
+        logger.debug(f"Queueing dial {dial_uid} value update to {value}")
+        self.dials[dial_uid]['value'] = value
+        self.dials[dial_uid]['value_changed'] = True
+        return True
+
+    # Debug function, mainly used for dial offset/calibration
+    def dial_set_raw(self, dial_uid, value):
+        if not self._dial_exists(dial_uid):
+            logger.error(f"Dial {dial_uid} does not exist in dial list.")
+            return False
+
+        value = self._convert_to_int(value)
+        self.dial_driver.dial_single_set_raw(self.dials[dial_uid]['index'], value)
+        return True
+
+
+    # Debug function, mainly used for dial offset/calibration
+    def dial_set_calibration(self, dial_uid, value, fullScale=False):
+        if not self._dial_exists(dial_uid):
+            logger.error(f"Dial {dial_uid} does not exist in dial list.")
+            return False
+
+        value = self._convert_to_int(value)
+        self.dial_driver.dial_calibrate(self.dials[dial_uid]['index'], value, fullScale)
+        return True
+
+    def dial_set_easing_dial(self, dial_uid, step=None, period=None):
+        if not self._dial_exists(dial_uid):
+            logger.error(f"Dial {dial_uid} does not exist in dial list.")
+            return False
+
+        if step is not None:
+            step = self._convert_to_int(step)
+            self.dial_driver.dial_easing_dial_step(self.dials[dial_uid]['index'], step)
+
+        if period is not None:
+            period = self._convert_to_int(period)
+            self.dial_driver.dial_easing_dial_period(self.dials[dial_uid]['index'], period)
+
+        return True
+
+    def dial_set_easing_backlight(self, dial_uid, step=None, period=None):
+        if not self._dial_exists(dial_uid):
+            logger.error(f"Dial {dial_uid} does not exist in dial list.")
+            return False
+
+        if step is not None:
+            step = self._convert_to_int(step)
+            self.dial_driver.dial_easing_backlight_step(self.dials[dial_uid]['index'], step)
+
+        if period is not None:
+            period = self._convert_to_int(period)
+            self.dial_driver.dial_easing_backlight_period(self.dials[dial_uid]['index'], period)
+
+        return True
+
+    def dial_set_backlight(self, dial_uid, red, green, blue, white):
+        if not self._dial_exists(dial_uid):
+            logger.error(f"Dial {dial_uid} does not exist in dial list.")
+            return False
+
+        red = self._convert_to_int(red)
+        green = self._convert_to_int(green)
+        blue = self._convert_to_int(blue)
+        white = self._convert_to_int(white)
+
+        red = min(red, 100)
+        green = min(green, 100)
+        blue = min(blue, 100)
+        blue = min(blue, 100)
+        white = min(white, 100)
+
+        new_value = {'red':red, 'green':green, 'blue':blue, 'white':white }
+
+        # Check if already at value
+        if self.dials[dial_uid]['backlight'] == new_value:
+            logger.debug(f"Dial {dial_uid} already at {red}:{green}:{blue}:{white}")
+            return True
+
+        logger.debug(f"Queueing dial {dial_uid} RGBW update to {red}:{green}:{blue}:{white}")
+        self.dials[dial_uid]['backlight'] = {'red':red, 'green':green, 'blue':blue, 'white':white }
+        self.dials[dial_uid]['backlight_changed'] = True
+        return True
+
+    def dial_set_image(self, dial_uid, image_file):
+        if not self._dial_exists(dial_uid):
+            logger.error(f"Dial {dial_uid} does not exist in dial list.")
+            return False
+
+        logger.debug(f"Queueing dial {dial_uid} background image to {image_file}")
+        self.dials[dial_uid]['image_file'] = image_file
+        self.dials[dial_uid]['image_changed'] = True
+        return True
+
+    def dial_reload_info_from_hardware(self, dial_uid):
+        if not self._dial_exists(dial_uid):
+            logger.error(f"Dial {dial_uid} does not exist in dial list.")
+            return False
+
+        deviceIndex = int(self.dials[dial_uid]['index'])
+
+        fw_hash = self.dial_driver.dial_get_fw_hash(deviceIndex)
+        fw_version = self.dial_driver.dial_get_fw_version(deviceIndex)
+        hw_version = self.dial_driver.dial_get_hw_version(deviceIndex)
+        protocol_version = self.dial_driver.dial_get_protocol_version(deviceIndex)
+        deviceEasing = self.dial_driver.dial_easing_get_config(deviceIndex)   # Read dial easing config
+
+        self.dials[dial_uid]['fw_hash'] = fw_hash
+        self.dials[dial_uid]['fw_version'] = fw_version
+        self.dials[dial_uid]['hw_version'] = hw_version
+        self.dials[dial_uid]['protocol_version'] = protocol_version
+        self.dials[dial_uid]['easing']['dial_step'] = deviceEasing['dial_step']
+        self.dials[dial_uid]['easing']['dial_period'] = deviceEasing['dial_period']
+        self.dials[dial_uid]['easing']['backlight_step'] = deviceEasing['backlight_step']
+        self.dials[dial_uid]['easing']['backlight_period'] = deviceEasing['backlight_period']
+
+        self.server_config.update_dial_db_cell(dial_uid, 'dial_build_hash', fw_hash)
+        self.server_config.update_dial_db_cell(dial_uid, 'dial_fw_version', fw_version)
+        self.server_config.update_dial_db_cell(dial_uid, 'dial_hw_version', hw_version)
+        self.server_config.update_dial_db_cell(dial_uid, 'dial_protocol_version', protocol_version)
+        self.server_config.update_dial_db_cell(dial_uid, 'easing_dial_step', deviceEasing['dial_step'])
+        self.server_config.update_dial_db_cell(dial_uid, 'easing_dial_period', deviceEasing['dial_period'])
+        self.server_config.update_dial_db_cell(dial_uid, 'easing_backlight_step', deviceEasing['backlight_step'])
+        self.server_config.update_dial_db_cell(dial_uid, 'easing_backlight_period', deviceEasing['backlight_period'])
+
+        return self.dials[dial_uid]
+
+
+    def dial_reload_info_from_database(self, dial_uid):
+        if not self._dial_exists(dial_uid):
+            logger.error(f"Dial {dial_uid} does not exist in dial list.")
+            return False
+
+        dial_info = self.server_config.dial_fetch_db_info(dial_uid)
+
+        self.dials[dial_uid]['fw_hash'] = dial_info['dial_build_hash']
+        self.dials[dial_uid]['fw_version'] = dial_info['dial_fw_version']
+        self.dials[dial_uid]['hw_version'] = dial_info['dial_hw_version']
+        self.dials[dial_uid]['protocol_version'] = dial_info['dial_protocol_version']
+        self.dials[dial_uid]['easing']['dial_step'] = dial_info['easing_dial_step']
+        self.dials[dial_uid]['easing']['dial_period'] = dial_info['easing_dial_period']
+        self.dials[dial_uid]['easing']['backlight_step'] = dial_info['easing_backlight_step']
+        self.dials[dial_uid]['easing']['backlight_period'] = dial_info['easing_backlight_period']
+
+        return self.dials[dial_uid]

benchlab/vu/VU-Server/vu_notifications.py

@@ -0,0 +1,24 @@
+# pylint: disable=import-outside-toplevel
+import sys
+
+# TODO: Add support for Linux and Mac OS
+
+if sys.platform.lower() == "win32":
+    import ctypes
+
+    def show_error_msg(title, message):
+        ctypes.windll.user32.MessageBoxW(0, message, f"VU Server - {title}", 16)
+
+    def show_warning_msg(title, message):
+        ctypes.windll.user32.MessageBoxW(0, message, f"VU Server - {title}", 48)
+
+    def show_info_msg(title, message):
+        ctypes.windll.user32.MessageBoxW(0, message, f"VU Server - {title}", 64)
+
+else:
+    def show_error_msg(title, message):
+        pass
+    def show_warning_msg(title, message):
+        pass
+    def show_info_msg(title, message):
+        pass