flexCommunicator 0.1.0__py3-none-any.whl

flexCommunicator/clientLibraries/flcpy/node.py

@@ -0,0 +1,486 @@
+#**************************************************************************
+# * Copyright (C) 2025-present Bert Van Acker (B.MKR) <bva.bmkr@gmail.com>
+# *
+# * This file is part of the flexIA project.
+# *
+# * flexIA can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# *************************************************************************
+import yaml
+import jsonpickle
+import logging
+from datetime import datetime
+
+# OWN MODULES
+from flexCommunicator.clientLibraries.flcpy.communication.CommunicationManager import CommunicationManager
+from flexCommunicator.clientLibraries.flcpy.knowledge.KnowledgeManager import KnowledgeManager
+from flexCommunicator.clientLibraries.flcpy.logging.LoggingAndTracking import LoggingAndTrackingHandler
+from flexCommunicator.clientLibraries.flcpy.flexCloud.flexCloudManager import flexCloudManager
+from flexCommunicator.clientLibraries.flcpy.utils.Timer import Timer
+from flexCommunicator.clientLibraries.flcpy.flexCloud.flexCloudVariable import flexCloudVariable
+from flexCommunicator.clientLibraries.flcpy.security.security import *
+from flexCommunicator.clientLibraries.flcpy.transport.PropertyRegistry import PropertyRegistry
+from flexCommunicator.clientLibraries.flcpy.utils.constants import *
+
+# ---------------------------------------------------------------------------
+# Configuration Keys
+# ---------------------------------------------------------------------------
+KEY_EVENT_MANAGER_CONFIG = "Event_Manager_Config"
+KEY_MESSAGE_MANAGER_CONFIG = "Message_Manager_Config"
+KEY_LOGGER_CONFIG = "Logger_Config"
+KEY_KNOWLEDGE_CONFIG = "Knowledge_Config"
+KEY_APPLICATION_DESCRIPTOR = "application_Descriptor"
+KEY_LOG_LEVEL = "log_level"
+KEY_LOG_FORMAT = "format"
+KEY_PROTOCOL = "protocol"
+
+KEY_COMMUNICATION_MATRIX = "Communication_Matrix"
+KEY_DATA_MANAGER_CONFIG = "Data_Manager_Config"
+KEY_FLEXCLOUD_MANAGER_CONFIG = "flexCloud_Manager_Config"
+KEY_COMMUNICATION_MANAGERS_CONFIG = "Communication_managers"
+
+# ---------------------------------------------------------------------------
+# Default Values and Messages
+# ---------------------------------------------------------------------------
+DEFAULT_EVENT_MESSAGE = {}
+ENCODING_UTF8 = "utf-8"
+
+
+WARN_REGISTER_EVENT_CALLBACK_NOT_SET = "Event manager is not set for registering event callbacks."
+
+MSG_INITIALIZING_KNOWLEDGE = "Initializing knowledge: {} knowledge"
+MSG_INITIALIZING_EVENT_MANAGER = "Initializing Event Manager"
+MSG_INITIALIZING_IO_MANAGER = "Initializing IO Manager"
+MSG_USING_COMMUNICATION_MANAGER = "{} is using {} Communication Manager"
+MSG_STARTING = "{} is starting..."
+MSG_SHUTTING_DOWN = "{} is shutting down..."
+MSG_REGISTER_EVENT_CALLBACK = "Registered callback for event: {}"
+
+#flexCommunicator MESSAGES
+MSG_INITIALIZING_DATA_MANAGER = "Initializing Data Manager"
+MSG_INITIALIZING_FLEXCLOUD_MANAGER = "Initializing flexCloud Manager"
+MSG_INITIALIZING_APPLICATION_DESCRIPTOR = "Initializing flexCloud Manager"
+MSG_INITIALIZING_PROPERTY_REGISTRY = "Initializing Property Registry"
+
+# flexCommunicator WARNINGS
+WARN_NOT_IMPLEMENTED = "Called functions not implemented yet."
+WARN_DATA_MANAGER_NOT_SET = "Data manager is not set for setting data."
+WARN_KNOWLEDGE_MANAGER_NOT_SET = "knowledge manager is not set for storing data."
+WARN_EVENT_MANAGER_NOT_SET = "Event manager is not set for Event publishing."
+
+ERR_PROPERTY_REGISTRY_NOT_FOUND = "Given property is not defined in the communication matrix or transport protocol is not defined."
+ERR_COMMUNICATION_MANAGER_NOT_FOUND = "No matching communication manager found, please verify the transport protocol."
+
+# OTHER CONSTANTS
+BACKEND_REDIS = "redis"
+BACKEND_KAFKA = "kafka"
+
+class Node:
+    def __init__(self, config,loaded_config=False, communicationMatrix = None,multi_transport=False, verbose=False):
+        self.timers = []
+        if loaded_config:
+            self.config = config
+        else:
+            self.config = self.load_config(config)
+
+        # -- initialize application descriptor --
+        self.applicationDescriptor = self._initialize_application_descriptor()
+
+        # -- initialize logger --
+        self.logger = self._initialize_logger()
+        # -- initialize storage/knowledge --                            #ASSUMPTION:always redis of now
+        self.knowledge = self._initialize_knowledge()
+
+        # -- initialize data manager --
+        self.data_manager = self._initialize_data_manager()             #ASSUMPTION: if used, allows only one transport protocal per component
+        # -- initialize event manager --
+        self.event_manager = self._initialize_event_manager()           #TODO: determine if necessary in flexIA     #ASSUMPTION: MQTT or ROS2 supported
+        # -- initialize flexCloud manager --
+        self.flexCloud_manager = self._initialize_flexCloud_manager()   #ASSUMPTION: always redis cloud!
+
+        # Initialize MQTT and ROS2 Event
+        if self.event_manager:
+            self.logger.info(
+                MSG_USING_COMMUNICATION_MANAGER.format(
+                    self.__class__.__name__,
+                    self.config[KEY_EVENT_MANAGER_CONFIG][KEY_PROTOCOL]
+                )
+            )
+
+
+        # -- REGISTER APPLICATION STATUS AS FLEXCLOUD VARIABLE
+        self.application_status = flexCloudVariable(name=FLEXCLOUD_VARIABLES.STATUS,statusVariable=True)
+        self.register_flexCloud_variable(self.application_status)
+        self.application_status.set(value=APPLICATION_STATUS.INITIALIZING)
+
+        # -- LOAD COMMUNICATION MATRIX AND INITIALIZE PROPERTY REGISTRY
+        self.property_registry = self._initialize_property_registry(communicationMatrixFile=communicationMatrix)
+
+        # -- LOAD AND INITIALIZE MULTI-TRANSPORT COMMUNICATION MANAGERS
+        self._multi_transport = multi_transport
+        if multi_transport:
+            self._communicationManagers = []
+            comm_config = self.config[KEY_COMMUNICATION_MANAGERS_CONFIG]
+            for comm in comm_config:
+                transport_protocol = comm['Data_Manager_Config']['protocol']
+                comm_manager = self._initialize_communication_manager(transport_protocol=transport_protocol,config=comm)
+                self._communicationManagers.append(comm_manager)
+        else:
+            self._communicationManagers = []
+
+        x = 2
+
+    def load_config(self, config_file):
+        with open(config_file, 'r') as file:
+            return yaml.safe_load(file)
+
+    def _initialize_property_registry(self,communicationMatrixFile = "communicationMatrix.yaml"):
+        """ Initialize the property registry"""
+        try:
+            pr = PropertyRegistry(config_path=communicationMatrixFile)
+            self.logger.info(MSG_INITIALIZING_PROPERTY_REGISTRY)
+            return pr
+        except:
+            return None
+
+    def _initialize_logger(self):
+        # Create the main logger.
+        logger = logging.getLogger(self.__class__.__name__)
+        logger.setLevel(self.config[KEY_LOGGER_CONFIG][KEY_LOG_LEVEL])
+        # Instantiate the custom logging handler.
+        custom_handler = LoggingAndTrackingHandler(config=self.config[KEY_LOGGER_CONFIG], applicationDescriptor=self.applicationDescriptor)
+        formatter = logging.Formatter(self.config[KEY_LOGGER_CONFIG][KEY_LOG_FORMAT])
+        custom_handler.setFormatter(formatter)
+        logger.addHandler(custom_handler)
+        return logger
+
+    def _initialize_knowledge(self):
+        """Initialize the knowledge object based on the config."""
+        self.logger.info(
+            MSG_INITIALIZING_KNOWLEDGE.format(
+                self.config[KEY_KNOWLEDGE_CONFIG]["knowledge_type"]
+            )
+        )
+        return KnowledgeManager(self.config[KEY_KNOWLEDGE_CONFIG])
+
+    def _initialize_event_manager(self):
+        """Initialize the Event Manager based on the config."""
+        self.logger.info(MSG_INITIALIZING_EVENT_MANAGER)
+        return CommunicationManager(config=self.config[KEY_EVENT_MANAGER_CONFIG])
+
+    def _initialize_flexCloud_manager(self):
+        """Initialize the Event Manager based on the config."""
+        self.logger.info(MSG_INITIALIZING_FLEXCLOUD_MANAGER)
+        return flexCloudManager(config=self.config[KEY_FLEXCLOUD_MANAGER_CONFIG])
+
+
+    def _initialize_data_manager(self):
+        """Initialize the Data Manager based on the config."""
+        self.logger.info(MSG_INITIALIZING_IO_MANAGER)
+        return CommunicationManager(config=self.config[KEY_DATA_MANAGER_CONFIG])
+
+    def _initialize_application_descriptor(self):
+        """Initialize the application description based on the config."""
+        #self.logger.info(MSG_INITIALIZING_APPLICATION_DESCRIPTOR)
+        return self.config[KEY_APPLICATION_DESCRIPTOR]
+
+    def spin(self):
+        """Start the component and enable Event."""
+        self.logger.info(MSG_STARTING.format(self.__class__.__name__))
+        if self.event_manager:
+            self.event_manager.start()
+        if self.data_manager:
+            self.data_manager.start()
+        if self._multi_transport:
+            for comm in self._communicationManagers:
+                comm.start()
+        # activate all auto-start timers
+        for timer in self.timers:
+            timer.start()
+
+    def shutdown(self):
+        """Shutdown the component and stop Event."""
+        self.logger.info(MSG_SHUTTING_DOWN.format(self.__class__.__name__))
+        if self.event_manager:
+            self.event_manager.stop()
+        if self.data_manager:
+            self.data_manager.stop()
+        if self._multi_transport:
+            for comm in self._communicationManagers:
+                comm.stop()
+        # deactivate all auto-start timers
+        for timer in self.timers:
+            timer.stop()
+            
+
+    def publish_event(self, event_key, message=DEFAULT_EVENT_MESSAGE):
+        """Publish Event using the Event manager."""
+        # Generate a unique ID for the message
+        message_id = str(uuid.uuid4().hex[:8])
+        # Get the current timestamp in ISO 8601 format
+        timestamp = datetime.now().isoformat()
+        
+        message['uid'] = message_id
+        message['timestamp'] = timestamp
+    
+        if self.event_manager:
+            self.event_manager.publish(event_key,  json.dumps(message))
+        else:
+            self.logger.warning(WARN_EVENT_MANAGER_NOT_SET)
+
+    #def publish_message(self, event_key, message=DEFAULT_EVENT_MESSAGE):
+    #    """Publish Event using the Event manager."""
+    #    if self.message_manager:
+    #        self.message_manager.publish(event_key, message)
+    #    else:
+    #        self.logger.warning(WARN_EVENT_MANAGER_NOT_SET)
+
+
+    def _read_knowledge(self, key, queueSize=1,decode=True):
+        """Read a value from the knowledge Manager."""
+        value = self.knowledge.read(key, queueSize)
+        if decode:
+            if value is not None:
+                value = value.decode(ENCODING_UTF8)  # Convert bytes to string
+                try:
+                    value = json.loads(value)  # Try to deserialize the value if it's a JSON string
+                except json.JSONDecodeError:
+                    pass  # If it's not JSON, return it as a string
+        return value
+
+    def _write_knowledge(self, key, value):
+        """Write a value to the knowledge Manager."""
+        if isinstance(key, str):
+            if isinstance(value, str):
+                value = str(value)
+            return self.knowledge.write(key, value)
+        else:
+            # Convert the class instance to a dictionary
+            class_dict = {}
+            for key_attr, attr_value in key.__dict__.items():
+                public_key = key_attr.lstrip('_')
+                class_dict[public_key] = attr_value
+            value = json.dumps(class_dict)  # Serialize the dictionary to a JSON string
+            return self.knowledge.write(key.name, value)
+
+    # --------------------------------------------------------------------------------------
+    # - ------------------------- flexCommunicator helpers ---------------------------------
+    # --------------------------------------------------------------------------------------
+    #TODO: move to auxiliary??
+    def _encode(self, message):
+        return jsonpickle.encode(message)
+
+
+    def _initialize_communication_manager(self,config=None,transport_protocol=''):
+        """Initialize a generic Communication Manager based on the config."""
+        self.logger.info(MSG_INITIALIZING_IO_MANAGER + " - TYPE: "+transport_protocol)
+        return CommunicationManager(config=config[KEY_DATA_MANAGER_CONFIG])
+
+    def _determine_communication_manager(self,transport_protocol):
+        _communication_manager = None
+        for comm in self._communicationManagers:
+            if comm.protocol == transport_protocol:
+                _communication_manager= comm
+
+        if _communication_manager == None:
+            self.logger.error(ERR_COMMUNICATION_MANAGER_NOT_FOUND)
+        return _communication_manager
+
+
+
+
+    # --------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------------------
+    #                               flexCommunicator API
+    # --------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------------------
+
+    # --------------------------------------------------------------------------------------
+    # - --------------------------------TIMERS  --------------------------------------------
+    # --------------------------------------------------------------------------------------
+    def create_timer(self,timer_period=1,callback=None, autostart = True):
+        """Creates a timer for periodic execution of functions"""
+        timer = Timer(timer_period, callback)
+        if autostart:
+            self.timers.append(timer)
+        return timer
+
+
+    #--------------------------------------------------------------------------------------
+    #-------------------------------DATA HANDLING -----------------------------------------
+    #--------------------------------------------------------------------------------------
+    def set_data(self, data_name="", data=DEFAULT_EVENT_MESSAGE):
+        """Publish or emit data as a message."""
+
+        #--------------- MULTI-TRANSPORT------------------------
+        if self._multi_transport:
+            # DETERMINE COMMUNCATION MANAGER FOR GIVEN DATA
+            protocol = self.property_registry.get_transport(name=data_name)
+            _comm_manager = self._determine_communication_manager(transport_protocol=protocol)
+            # DISABLE ENCODING FOR OPC-UA
+            if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_OPC_UA:
+                message_encoded = data
+            else:
+                message_encoded = self._encode(data)
+
+            if _comm_manager:
+                try:
+                    # determing transport binding for given data property
+                    transport = self.property_registry.get_binding(name=data_name, transport=protocol)
+                    _comm_manager.publish_transport(transport=transport, message=message_encoded)
+                except:
+                    self.logger.error(ERR_PROPERTY_REGISTRY_NOT_FOUND)
+            else:
+                self.logger.warning(WARN_DATA_MANAGER_NOT_SET)
+
+        # --------------- SINGLE-TRANSPORT USING DATA_MANAGER------------------------
+        else:
+            # DISABLE ENCODING FOR OPC-UA
+            if self.data_manager.protocol == TRANSPORT_PROTOCOLS.PROTOCOL_OPC_UA :
+                message_encoded = data
+            else:
+                message_encoded = self._encode(data)
+
+            if self.data_manager:
+                try:
+                    # determing transport binding for given data property
+                    transport = self.property_registry.get_binding(name=data_name,transport=self.data_manager.protocol)
+                    self.data_manager.publish_transport(transport=transport,message=message_encoded)
+                except:
+                    self.logger.error(ERR_PROPERTY_REGISTRY_NOT_FOUND)
+            else:
+                self.logger.warning(WARN_DATA_MANAGER_NOT_SET)
+
+    def get_data(self, data_name=""):
+        """Retrieve data."""
+        # --------------- MULTI-TRANSPORT------------------------
+        if self._multi_transport:
+            # DETERMINE COMMUNCATION MANAGER FOR GIVEN DATA
+            protocol = self.property_registry.get_transport(name=data_name)
+            _comm_manager = self._determine_communication_manager(transport_protocol=protocol)
+            if _comm_manager:
+                try:
+                    # determing transport binding for given data property
+                    transport = self.property_registry.get_binding(name=data_name,transport=_comm_manager.protocol)
+                    return _comm_manager.read_transport(transport=transport)
+                except:
+                    self.logger.error(ERR_PROPERTY_REGISTRY_NOT_FOUND)
+                    return -1
+            else:
+                self.logger.warning(WARN_DATA_MANAGER_NOT_SET)
+                return -1
+        # --------------- SINGLE-TRANSPORT USING DATA_MANAGER------------------------
+        else:
+            if self.data_manager:
+                try:
+                    # determing transport binding for given data property
+                    transport = self.property_registry.get_binding(name=data_name,transport=self.data_manager.protocol)
+                    return self.data_manager.read_transport(transport=transport)
+                except:
+                    self.logger.error(ERR_PROPERTY_REGISTRY_NOT_FOUND)
+                    return -1
+            else:
+                self.logger.warning(WARN_DATA_MANAGER_NOT_SET)
+                return -1
+
+    # --------------------------------------------------------------------------------------
+    # -------------------------------DATA HANDLING -----------------------------------------
+    # --------------------------------------------------------------------------------------
+    def store_data(self, data_name="", data=DEFAULT_EVENT_MESSAGE):
+        """Store data as a message in a knowledge service."""
+        message_encoded = self._encode(data)
+        if self.knowledge:
+            try:
+                # determing transport binding for given data property
+                data_key = self.property_registry.get_binding(name=data_name, transport=self.knowledge.backend).generic_endpoint
+                self._write_knowledge(key=data_key,value=message_encoded)
+            except:
+                self.logger.error(ERR_PROPERTY_REGISTRY_NOT_FOUND)
+        else:
+            self.logger.warning(WARN_KNOWLEDGE_MANAGER_NOT_SET)
+
+    def retrieve_data(self, data_name):
+        """Retrieve data stored as a message in a knowledge service."""
+        if self.knowledge:
+            try:
+                # determing transport binding for given data property
+                data_key = self.property_registry.get_binding(name=data_name, transport=self.knowledge.backend).generic_endpoint
+                data = self._read_knowledge(key=data_key,decode=False)
+            except:
+                data = None
+                self.logger.error(ERR_PROPERTY_REGISTRY_NOT_FOUND)
+        else:
+            data = None
+            self.logger.warning(WARN_KNOWLEDGE_MANAGER_NOT_SET)
+        return data
+
+    def delete_data(self, data_key, data=DEFAULT_EVENT_MESSAGE):
+        """Delete data stored as a message in a knowledge service."""
+        self.logger.warning(WARN_NOT_IMPLEMENTED)
+
+    def exists_data(self, data_key, data=DEFAULT_EVENT_MESSAGE):
+        """Check if data exists in a knowledge service."""
+        self.logger.warning(WARN_NOT_IMPLEMENTED)
+
+    def register_data_callback(self, data_name, callback):
+        """Register a callback for Data manager events (MQTT or Redis)."""
+        # --------------- MULTI-TRANSPORT------------------------
+        if self._multi_transport:
+            # DETERMINE COMMUNCATION MANAGER FOR GIVEN DATA
+            protocol = self.property_registry.get_transport(name=data_name)
+            _comm_manager = self._determine_communication_manager(transport_protocol=protocol)
+            if _comm_manager:
+                transport = self.property_registry.get_binding(name=data_name, transport=_comm_manager.protocol)
+                _comm_manager.subscribe_transport(transport=transport, callback=callback)
+                self.logger.info(MSG_REGISTER_EVENT_CALLBACK.format(data_name))
+            else:
+                self.logger.warning(WARN_REGISTER_EVENT_CALLBACK_NOT_SET)
+
+        # --------------- SINGLE-TRANSPORT USING DATA_MANAGER------------------------
+        else:
+            if self.data_manager:
+                transport = self.property_registry.get_binding(name=data_name, transport=self.data_manager.protocol)
+                self.data_manager.subscribe_transport(transport=transport, callback=callback)
+                self.logger.info(MSG_REGISTER_EVENT_CALLBACK.format(data_name))
+            else:
+                self.logger.warning(WARN_REGISTER_EVENT_CALLBACK_NOT_SET)
+
+    # --------------------------------------------------------------------------------------
+    # - -----------------------------EVENT HANDLING -----------------------------------------
+    # --------------------------------------------------------------------------------------
+    def emit_event(self, event_key, data=DEFAULT_EVENT_MESSAGE):
+        """Publish or emit event as a message."""
+        message_encoded = self._encode(data)
+        if self.event_manager:
+            self.event_manager.publish(event_key, message_encoded)
+        else:
+            self.logger.warning(WARN_EVENT_MANAGER_NOT_SET)
+    def register_event_callback(self, event_key, callback):
+        """Register a callback for Event manager events (MQTT or Redis)."""
+        #TODO: add timestamp and unique ID to event message
+        if self.event_manager:
+            self.event_manager.subscribe(event_key, callback)
+            self.logger.info(MSG_REGISTER_EVENT_CALLBACK.format(event_key))
+        else:
+            self.logger.warning(WARN_REGISTER_EVENT_CALLBACK_NOT_SET)
+
+    # --------------------------------------------------------------------------------------
+    # - -----------------------flexCloud variable handling ---------------------------------
+    # --------------------------------------------------------------------------------------
+    def register_flexCloud_variable(self,variable=None):
+        """Register a flexCloud variable."""
+        # assign flexCloud manager + assign flexCloud connectorID
+        variable.flexCloud_manager = self.flexCloud_manager
+        variable.flexCloud_connectorID = self._get_flexCloud_connectorID()
+        variable.flexCloud_applicationID = self.applicationDescriptor["id"]
+        self.logger.info("flexCloud variable registered, name:" + variable._name)
+
+    def _get_flexCloud_connectorID(self):
+
+        # TODO: determine the connectorID, either static or dynamic via OS variables
+        if self.applicationDescriptor["connectorID_type"] == "static":
+            flexCloud_connectorID = self.applicationDescriptor["connectorID"]
+        else:
+            flexCloud_connectorID = get_os_variable(SECURITY_STORE.FLEXCLOUD_CONNECTORID_SECRET)
+
+        return flexCloud_connectorID

flexCommunicator/clientLibraries/flcpy/security/security.py

@@ -0,0 +1,189 @@
+#**************************************************************************
+# * Copyright (C) 2025-present Bert Van Acker (B.MKR) <bva.bmkr@gmail.com>
+# *
+# * This file is part of the flexIA project.
+# *
+# * flexIA can not be copied and/or distributed without the express
+# * permission of Bert Van Acker
+# *************************************************************************
+import os
+import uuid
+import json
+import hmac
+import hashlib
+import secrets
+import bcrypt
+import random
+import string
+
+from flexCommunicator.clientLibraries.flcpy.utils.constants import *
+def compute_signature(command):
+    # Create a consistent string representation including the new fields
+    SHARED_SECRET = os.environ.get(SECURITY_STORE.FLEXCLOUD_ACTIVE_SHARED_KEY)
+
+    # KEY FOR BETA-TESTING!! REMOVE WHEN DEPLOYED
+    if SHARED_SECRET is None:
+        SHARED_SECRET = "b'\\xae\\xc1?\\x14\\xb3X\\xb1\\xb9#\\xbe\\xe6\\x9d\\xab\\x82])9\\xb9\\xa1*\\xf5=~\\x04p\\xe0\\x9a\\x0c\\x1b\\x17\\xd5\\x9c'"
+
+    data_to_sign = (
+        command["id"] +
+        command["cmd"] +
+        str(command["priority"]) +
+        str(command["expiry"]) +
+        json.dumps(command["params"], sort_keys=True) +
+        str(command["timestamp"]) +
+        command["nonce"]
+    )
+    return hmac.new(SHARED_SECRET.encode(), data_to_sign.encode(), hashlib.sha256).hexdigest()
+
+def verify_signature(command):
+    SHARED_SECRET = os.environ.get(SECURITY_STORE.FLEXCLOUD_ACTIVE_SHARED_KEY)
+
+    # KEY FOR BETA-TESTING!! REMOVE WHEN DEPLOYED
+    if SHARED_SECRET is None:
+        SHARED_SECRET = "b'\\xae\\xc1?\\x14\\xb3X\\xb1\\xb9#\\xbe\\xe6\\x9d\\xab\\x82])9\\xb9\\xa1*\\xf5=~\\x04p\\xe0\\x9a\\x0c\\x1b\\x17\\xd5\\x9c'"
+
+    expected = hmac.new(
+        SHARED_SECRET.encode(),
+        (
+            command["id"] +
+            command["cmd"] +
+            str(command["priority"]) +
+            str(command["expiry"]) +
+            json.dumps(command["params"], sort_keys=True) +
+            str(command["timestamp"]) +
+            command["nonce"]
+        ).encode(),
+        hashlib.sha256
+    ).hexdigest()
+    return hmac.compare_digest(expected, command["signature"])
+
+
+def generate_shared_secret(length=32):
+    """
+    Generates a cryptographically secure random shared secret.
+
+    Args:
+        length (int): The number of bytes for the secret (default 32 bytes for 256 bits).
+
+    Returns:
+        bytes: The generated shared secret.
+    """
+    return secrets.token_bytes(length)
+
+import os
+
+def register_os_variable(secret, env_var_name=SECURITY_STORE.FLEXCLOUD_ACTIVE_SHARED_KEY):
+    """
+    Stores a given shared secret in an OS environment variable.
+
+    Args:
+        secret (str or bytes): The shared secret to store. If bytes, it will be converted to a hexadecimal string.
+        env_var_name (str): The name of the environment variable to set (default is "SHARED_SECRET").
+
+    Note:
+        This only affects the current process (and its child processes). It does not persist across reboots
+        or new sessions.
+    """
+    # If the secret is provided as bytes, convert it to a hex string for easier storage
+    if isinstance(secret, bytes):
+        secret = secret.hex()
+    try:
+        os.environ[env_var_name] = secret
+        return True
+    except:
+        return False
+
+def get_os_variable(env_var_name=""):
+    return os.getenv(env_var_name)
+
+def generate_app_tag(prefix="APP", unique_length=10):
+    """
+    Generates a unique tag for an application.
+
+    The tag is composed of a prefix and a unique identifier generated
+    from a UUID. The unique identifier is taken as the first `unique_length`
+    characters of the hexadecimal representation of a UUID.
+
+    Args:
+        prefix (str): A string to prefix the tag (default is "APP").
+        unique_length (int): Number of characters from the UUID to use (default is 8).
+
+    Returns:
+        str: The generated application tag.
+    """
+    # Generate a UUID and take the first `unique_length` characters of its hex representation
+    unique_part = uuid.uuid4().hex[:unique_length]
+    if prefix is not None:
+        return f"{prefix}-{unique_part}"
+    else:
+        return unique_part
+
+
+def hash_password(password: str) -> str:
+    """
+    Hash a password using bcrypt.
+
+    Args:
+        password (str): The plaintext password to hash.
+
+    Returns:
+        str: The hashed password.
+    """
+    # Convert the password to bytes
+    password_bytes = password.encode('utf-8')
+    # Generate a salt (the default work factor is secure for most purposes)
+    salt = bcrypt.gensalt()
+    # Generate the hashed password
+    hashed_password = bcrypt.hashpw(password_bytes, salt)
+    # Return the hashed password as a string
+    return hashed_password.decode('utf-8')
+
+
+
+
+def generate_custom_strong_password(length=12, use_upper=True, use_lower=True, use_digits=True, use_symbols=True):
+    """
+    Generates a custom strong password.
+
+    Parameters:
+        length (int): Desired total length of the password.
+        use_upper (bool): If True, include uppercase letters.
+        use_lower (bool): If True, include lowercase letters.
+        use_digits (bool): If True, include digits.
+        use_symbols (bool): If True, include punctuation/symbols.
+
+    Returns:
+        str: A randomly generated strong password.
+
+    Raises:
+        ValueError: If no character sets are selected or length is too short.
+    """
+    # Build list of chosen character sets
+    char_sets = []
+    if use_upper:
+        char_sets.append(string.ascii_uppercase)
+    if use_lower:
+        char_sets.append(string.ascii_lowercase)
+    if use_digits:
+        char_sets.append(string.digits)
+    if use_symbols:
+        char_sets.append(string.punctuation)
+
+    if not char_sets:
+        raise ValueError("At least one type of characters must be selected.")
+
+    # Ensure the password length can include at least one character from each selected set
+    if length < len(char_sets):
+        raise ValueError(f"Password length must be at least {len(char_sets)} to include one of each selected type.")
+
+    # Guarantee each selected type is represented at least once
+    password_chars = [random.choice(char_set) for char_set in char_sets]
+
+    # Fill the rest of the password length with a random selection from all allowed characters
+    all_allowed_chars = ''.join(char_sets)
+    password_chars += random.choices(all_allowed_chars, k=length - len(password_chars))
+
+    # Shuffle the list to ensure randomness and then convert it to a string
+    random.shuffle(password_chars)
+    return ''.join(password_chars)