flexCommunicator 0.1.0__py3-none-any.whl

flexCommunicator/clientLibraries/flcpy/flexNode.py

@@ -0,0 +1,892 @@
+#**************************************************************************
+# * 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 jsonpickle.ext.numpy as jsonpickle_numpy
+# 2. Register the NumPy handlers
+jsonpickle_numpy.register_handlers()
+
+import logging
+from datetime import datetime
+
+from flexCommunicator.clientLibraries.flcpy.commands.composer import compose_command
+# 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 *
+from flexCommunicator.clientLibraries.flcpy.commands.commandProcessor import *
+from flexCommunicator.clientLibraries.flcpy.utils.decorators import *
+from flexCommunicator.clientLibraries.flcpy.service.client import client
+from flexCommunicator.clientLibraries.flcpy.action.goal_handle import goal_handle
+from flexCommunicator.clientLibraries.flcpy.action.action_client import ation_client
+from flexCommunicator.clientLibraries.flcpy.fmi.fmuNode import *
+from flexCommunicator.clientLibraries.flcpy.validityFrame.validityFrameManager import *
+
+#versioning
+from packaging.version import Version
+# ---------------------------------------------------------------------------
+# GLOBAL VARIABLES
+# ---------------------------------------------------------------------------
+GLOBAL_REQ_KEY = None
+
+
+
+
+
+class flexNode:
+    def __init__(self, config,loaded_config=False, communicationMatrix = None,multi_transport=True,version="0.0a1", verbose=False):
+        self._verbose = verbose
+        self.timers = []
+        self.services = []
+
+        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 flexCloud manager --
+        self.flexCloud_manager = self._initialize_flexCloud_manager()   #ASSUMPTION: always redis cloud!
+
+        # -- 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[CONFIG_KEYS.KEY_COMMUNICATION_MANAGERS_CONFIG]
+            if comm_config is not None:
+                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.logger.warning(FLEXCLOUD_WARNINGS.WARN_EMPTY_COMMUNICATION_MANAGERS)
+        else:
+            self._communicationManagers = []
+
+        # -- SUBSCRIBE TO COMMANDS FROM FLEXCLOUD --
+        self._cmd_key = self._get_flexCloud_command_key()
+        self.flexCloud_manager.subscribe(topic=self._cmd_key, callback=self._on_command)
+
+        # -- SETUP COMMAND PROCESSOR --
+        self._command_processor = commandProcessor(name="flexNode_CMD_PROCESSOR",logger=self.logger,verbose=verbose)
+
+        # -- SETUP REQUIREMENTS LINKING --
+        self.requirements_key = self._get_flexCloud_connectorID() + FLEXCLOUD_VARIABLES.APPLICATIONS + self.applicationDescriptor["id"] + FLEXCLOUD_VARIABLES.REQUIREMENTS
+
+        # -- SETUP APPLICATION PROFILER --
+        self.application_profiler_key = self._get_flexCloud_connectorID() + FLEXCLOUD_VARIABLES.APPLICATIONS + self.applicationDescriptor["id"] + FLEXCLOUD_VARIABLES.PROFILING
+
+        # -- FMI integration --
+        self._fmu_list = []
+        self._rt_fmu=None
+
+        # -- application metadata --
+        self._name = "tbd"
+        self._id = "tbd"
+        self._description = "tbd"
+        self._version = "tbd"
+
+        # -- VALIDITY FRAME INTEGRATION --
+        self.vf = None   # WARNING: ONLY ONE VF PER NODE FOR NOW!
+        self.vf_key = self._get_flexCloud_connectorID() + FLEXCLOUD_VARIABLES.APPLICATIONS + self.applicationDescriptor["id"] + FLEXCLOUD_VARIABLES.VALIDITY_FRAME
+
+
+    # --------------------------------------------------------------------------------------
+    # - --------------- Application meta-data ----------------------------------------------
+    # --------------------------------------------------------------------------------------
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self,name):
+        self._name = name
+
+    @property
+    def ID(self):
+        return self._id
+
+    @ID.setter
+    def ID(self, id):
+        self._id = id
+
+    @property
+    def description(self):
+        return self._description
+
+    @description.setter
+    def description(self, desc):
+        self._description = desc
+
+
+    @property
+    def version(self):
+        return self._version
+
+    @version.setter
+    def version(self,version):
+        self._version = Version(version)
+
+
+    def logInit(self):
+        self.logger.info(self.name + "instantiated with ID: " + self.ID + " - version [" + str(self.version) + "]")
+
+    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(FLEXCLOUD_MESSAGES.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[CONFIG_KEYS.KEY_LOGGER_CONFIG][CONFIG_KEYS.KEY_LOG_LEVEL])
+        # Instantiate the custom logging handler.
+        custom_handler = LoggingAndTrackingHandler(config=self.config[CONFIG_KEYS.KEY_LOGGER_CONFIG], applicationDescriptor=self.applicationDescriptor)
+        formatter = logging.Formatter(self.config[CONFIG_KEYS.KEY_LOGGER_CONFIG][CONFIG_KEYS.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(
+            FLEXCLOUD_MESSAGES.MSG_INITIALIZING_KNOWLEDGE.format(
+                self.config[CONFIG_KEYS.KEY_KNOWLEDGE_CONFIG]["knowledge_type"]
+            )
+        )
+        return KnowledgeManager(self.config[CONFIG_KEYS.KEY_KNOWLEDGE_CONFIG])
+
+    def _initialize_flexCloud_manager(self):
+        """Initialize the Event Manager based on the config."""
+        self.logger.info(FLEXCLOUD_MESSAGES.MSG_INITIALIZING_FLEXCLOUD_MANAGER)
+        return flexCloudManager(config=self.config[CONFIG_KEYS.KEY_FLEXCLOUD_MANAGER_CONFIG])
+
+
+    def _initialize_application_descriptor(self):
+        """Initialize the application description based on the config."""
+        return self.config[CONFIG_KEYS.KEY_APPLICATION_DESCRIPTOR]
+
+    def spin(self):
+        """Start the component and enable Event."""
+        self.logger.info(FLEXCLOUD_MESSAGES.MSG_STARTING.format(self.__class__.__name__))
+        if self._multi_transport:
+            for comm in self._communicationManagers:
+                comm.start()
+        else:
+            self.logger.warning(FLEXCLOUD_WARNINGS.WARN_EMPTY_COMMUNICATION_MANAGERS)
+        # activate all auto-start timers
+        for timer in self.timers:
+            timer.start()
+        # activate flexCloud commands
+        self.flexCloud_manager.start()
+
+    def shutdown(self):
+
+        """Shutdown the component and stop Event."""
+        self.logger.info(FLEXCLOUD_MESSAGES.MSG_SHUTTING_DOWN.format(self.__class__.__name__))
+        # set application status to stopped
+        self.application_status.set(value=APPLICATION_STATUS.STOPPED)
+        if self._multi_transport:
+            for comm in self._communicationManagers:
+                comm.stop()
+        # deactivate all auto-start timers
+        for timer in self.timers:
+            timer.stop()
+        # activate flexCloud commands
+        self.flexCloud_manager.stop()
+
+
+
+    # --------------------------------------------------------------------------------------
+    # - --------------- flexCommunicator event helpers -------------------------
+    # --------------------------------------------------------------------------------------
+    def _publish_event(self, event_key, message=DEFAULT_MESSAGES.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
+
+        #TODO: change to use transport protocol defined to event
+        if self.event_manager:
+            self.event_manager.publish(event_key,  json.dumps(message))
+        else:
+            self.logger.warning(FLEXCLOUD_WARNINGS.WARN_EVENT_MANAGER_NOT_SET)
+
+    # --------------------------------------------------------------------------------------
+    # - --------------- flexCommunicator Knowledge/storage helpers -------------------------
+    # --------------------------------------------------------------------------------------
+
+    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.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,history=False):
+        """Write a value to the knowledge Manager."""
+        success=False
+        if isinstance(key, str):
+            if isinstance(value, str):
+                value = str(value)
+                if history:
+                    success = self.knowledge.write_history(key, value)
+                else:
+                    success=self.knowledge.write(key, value)
+            return success
+        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
+            if history:
+                success = self.knowledge.write_history(key, value)
+            else:
+                success = self.knowledge.write(key, value)
+            return success
+
+    # --------------------------------------------------------------------------------------
+    # - ------------------------- 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(FLEXCLOUD_MESSAGES.MSG_INITIALIZING_IO_MANAGER + " - TYPE: "+transport_protocol)
+        return CommunicationManager(config=config[CONFIG_KEYS.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(FLEXCLOUD_ERRORS.ERR_COMMUNICATION_MANAGER_NOT_FOUND)
+        return _communication_manager
+
+    def _check_available_communication_manager(self,transport_protocol):
+        available = False
+        for comm in self._communicationManagers:
+            if comm.protocol == transport_protocol:
+                available = True
+                break
+        if available is False:
+            self.logger.warning(FLEXCLOUD_WARNINGS.WARN_NO_MATCHING_TRANSPORT_PROTOCOL + transport_protocol)
+        return available
+
+
+
+    # --------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------------------
+    #                               flexCommunicator API
+    # --------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------------------
+
+    # --------------------------------------------------------------------------------------
+    # - --------------------------------TIMERS  --------------------------------------------
+    # --------------------------------------------------------------------------------------
+    def create_timer(self,timer_period=0.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_MESSAGES.DEFAULT_DATA_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 or protocol == TRANSPORT_PROTOCOLS.PROTOCOL_TWINCAT_ADS:
+                message_encoded = data
+            # DISABLE ENCODING FOR STRING type
+            elif isinstance(data, str):
+                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(FLEXCLOUD_ERRORS.ERR_PROPERTY_REGISTRY_NOT_FOUND)
+            else:
+                self.logger.warning(FLEXCLOUD_WARNINGS.WARN_DATA_MANAGER_NOT_SET)
+
+        # --------------- SINGLE-TRANSPORT USING DATA_MANAGER------------------------
+        else:
+            self.logger.warning(FLEXCLOUD_WARNINGS.WARN_SINGLE_COMMUNICATION_MANAGER_DEPRICATED)
+
+
+    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(FLEXCLOUD_ERRORS.ERR_PROPERTY_REGISTRY_NOT_FOUND)
+                    return -1
+            else:
+                self.logger.warning(FLEXCLOUD_WARNINGS.WARN_DATA_MANAGER_NOT_SET)
+                return -1
+        # --------------- SINGLE-TRANSPORT USING DATA_MANAGER------------------------
+        else:
+            self.logger.warning(FLEXCLOUD_WARNINGS.WARN_SINGLE_COMMUNICATION_MANAGER_DEPRICATED)
+            return -1
+
+    def register_data_callback(self, data_name, callback,isService=False):
+        """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,isService=isService)
+                self.logger.info(FLEXCLOUD_MESSAGES.MSG_REGISTER_EVENT_CALLBACK.format(data_name))
+            else:
+                self.logger.warning(FLEXCLOUD_WARNINGS.WARN_REGISTER_EVENT_CALLBACK_NOT_SET)
+
+        # --------------- SINGLE-TRANSPORT USING DATA_MANAGER------------------------
+        else:
+            self.logger.warning(FLEXCLOUD_WARNINGS.WARN_SINGLE_COMMUNICATION_MANAGER_DEPRICATED)
+
+
+    # --------------------------------------------------------------------------------------
+    # -------------------------------DATA STORAGE HANDLING -----------------------------------------
+    # --------------------------------------------------------------------------------------
+    def store_data(self, data_name="", data=DEFAULT_MESSAGES.DEFAULT_DATA_MESSAGE,history=False):
+        """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,history=history)
+            except:
+                self.logger.error(FLEXCLOUD_ERRORS.ERR_PROPERTY_REGISTRY_NOT_FOUND)
+        else:
+            self.logger.warning(FLEXCLOUD_WARNINGS.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(FLEXCLOUD_ERRORS.ERR_PROPERTY_REGISTRY_NOT_FOUND)
+        else:
+            data = None
+            self.logger.warning(FLEXCLOUD_WARNINGS.WARN_KNOWLEDGE_MANAGER_NOT_SET)
+        return data
+
+    def delete_data(self, data_key, data=DEFAULT_MESSAGES.DEFAULT_DATA_MESSAGE):
+        """Delete data stored as a message in a knowledge service."""
+        self.logger.warning(FLEXCLOUD_WARNINGS.WARN_NOT_IMPLEMENTED)
+
+    def exists_data(self, data_key, data=DEFAULT_MESSAGES.DEFAULT_DATA_MESSAGE):
+        """Check if data exists in a knowledge service."""
+        self.logger.warning(FLEXCLOUD_WARNINGS.WARN_NOT_IMPLEMENTED)
+
+
+
+    # --------------------------------------------------------------------------------------
+    # - -----------------------------EVENT HANDLING -----------------------------------------
+    # --------------------------------------------------------------------------------------
+    def emit_event(self, event_key, data=DEFAULT_MESSAGES.DEFAULT_EVENT_MESSAGE):
+        """Publish or emit event as a message."""
+        message_encoded = self._encode(data)
+        # TODO: change to use transport protocol defined to event
+        if self.event_manager:
+            self.event_manager.publish(event_key, message_encoded)
+        else:
+            self.logger.warning(FLEXCLOUD_WARNINGS.WARN_EVENT_MANAGER_NOT_SET)
+    def register_event_callback(self, event_key, callback):
+        """Register a callback for Event manager events (MQTT or Redis)."""
+        #TODO: change to use transport protocol defined to event
+        if self.event_manager:
+            self.event_manager.subscribe(event_key, callback)
+            self.logger.info(FLEXCLOUD_MESSAGES.MSG_REGISTER_EVENT_CALLBACK.format(event_key))
+        else:
+            self.logger.warning(FLEXCLOUD_WARNINGS.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"]
+        variable.initialize()
+        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
+
+    def _get_flexCloud_command_key(self):
+
+        if self.applicationDescriptor["connectorID_type"] == "static":
+            flexCloud_connectorID = self.applicationDescriptor.get("connectorID","default@default-1aa111")
+        else:
+            flexCloud_connectorID = get_os_variable(SECURITY_STORE.FLEXCLOUD_CONNECTORID_SECRET)
+
+        flexCloud_application_id = self.applicationDescriptor.get("id", "default")
+        flexCloud_command_key = flexCloud_connectorID+":"+flexCloud_application_id+FLEXCLOUD_KEYS.COMMAND
+
+        return flexCloud_command_key
+
+    def _get_flexCloud_command_response_key(self):
+
+        if self.applicationDescriptor["connectorID_type"] == "static":
+            flexCloud_connectorID = self.applicationDescriptor.get("connectorID","default@default-1aa111")
+        else:
+            flexCloud_connectorID = get_os_variable(SECURITY_STORE.FLEXCLOUD_CONNECTORID_SECRET)
+
+        flexCloud_application_id = self.applicationDescriptor.get("id", "default")
+        flexCloud_command_key = flexCloud_connectorID+":"+flexCloud_application_id+FLEXCLOUD_KEYS.RESPONSE
+
+        return flexCloud_command_key
+
+    # --------------------------------------------------------------------------------------
+    # - -----------------------flexCloud command handling ---------------------------------
+    # --------------------------------------------------------------------------------------
+    def _on_command(self,message):
+        """Process the incoming commands"""
+        #determine command action and data
+        signature_valid,action,data = self._command_processor.process_command(message)
+
+        if signature_valid:
+            if action == FLEXCLOUD_COMMANDS.PING:
+                #PUBLISH APPLICATION STATUS
+                params = {"applicationName": self.applicationDescriptor.get("id","default"),"applicationStatus": self.application_status.get()}
+                response = compose_command(FLEXCLOUD_COMMANDS.PONG, params, priority=2, expiry_seconds=120)
+                response_key = self._get_flexCloud_command_response_key()
+                self.flexCloud_manager.publish(key=response_key,value=response)
+
+            elif action == FLEXCLOUD_COMMANDS.UPDATE_TRANSPORT:
+                # CHANGE PROPERTY PROTOCOL
+                changeAllowed = self._check_available_communication_manager(transport_protocol=data["protocol"])
+                updated = False
+                # CHECK IF ALLOWED TO CHANGE PROTOCOL (IF PROTOCOL CLIENT IS AVAILABLE)
+                if changeAllowed:
+                    updated = self.property_registry.update_transport(name=data["propertyName"],transport=data["protocol"])
+
+                if updated:
+                    params = {"propertyName": data["propertyName"],"protocol": self.property_registry.get_transport(data["propertyName"]),"status":"Succeeded"}
+                    response = compose_command(FLEXCLOUD_COMMANDS.UPDATE_TRANSPORT, params, priority=2, expiry_seconds=120)
+                    self.logger.info(FLEXCLOUD_MESSAGES.MSG_UPDATE_PROPERTY_PROTOCOL_SUCCESS + data["propertyName"]+ " - new protocol: "+self.property_registry.get_transport(data["propertyName"]))
+                else:
+                    params = {"propertyName": data["propertyName"],"protocol": self.property_registry.get_transport(data["propertyName"]),"status":"Failed"}
+                    response = compose_command(FLEXCLOUD_COMMANDS.UPDATE_TRANSPORT, params, priority=2,expiry_seconds=120)
+                    self.logger.info(FLEXCLOUD_ERRORS.ERR_UPDATE_PROPERTY_PROTOCOL_FAIL + data["propertyName"]+" - requested protocol: " +data["protocol"])
+
+                response_key = self._get_flexCloud_command_response_key()
+                self.flexCloud_manager.publish(key=response_key, value=response)
+
+            return True
+        else:
+            self.logger.error(FLEXCLOUD_ERRORS.ERR_INVALID_COMMAND_SIGNATURE)
+            return False
+
+    # --------------------------------------------------------------------------------------
+    # - -------------------Contract-based component functions ------------------------------
+    # --------------------------------------------------------------------------------------
+    def register_contract_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"]
+        variable.initialize()
+        self.logger.info("Contract variable registered, name:" + variable._name)
+
+    # --------------------------------------------------------------------------------------
+    # - -------------------Validity Frame component functions ------------------------------
+    # --------------------------------------------------------------------------------------
+    def register_runtime_monitor(self, monitor=None):
+        """Register a VF runtime monitor."""
+        # assign flexCloud manager + assign flexCloud connectorID
+        monitor.flexCloud_manager = self.flexCloud_manager
+        monitor.flexCloud_connectorID = self._get_flexCloud_connectorID()
+        monitor.flexCloud_applicationID = self.applicationDescriptor["id"]
+        monitor.initialize()
+        self.logger.info("VF runtime monitor registered, name:" + monitor._name)
+
+    # --------------------------------------------------------------------------------------
+    # - --------------------------------SERVICES --------------------------------------------
+    # --------------------------------------------------------------------------------------
+    def create_service(self, protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,service=None,serviceName='TBD', callback=None):
+        """Creates and registers a new service."""
+        if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_MQTT or protocol == TRANSPORT_PROTOCOLS.PROTOCOL_REDIS:
+            #register service to node
+
+            if serviceName is not None:
+                #add property to and resolve name
+                if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_MQTT:
+                    self.property_registry.add_property(name=serviceName+"_request",description="Request property for service <"+serviceName+">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,mqtt="/"+serviceName+"/_request")
+                    self.property_registry.add_property(name=serviceName + "_response",description="Response property for service <" + serviceName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT, mqtt="/" + serviceName + "/_response")
+                    self.register_data_callback(data_name=serviceName+"_request",callback=self.generic_service_callback,isService=True)
+                elif protocol == TRANSPORT_PROTOCOLS.PROTOCOL_REDIS:
+                    self.property_registry.add_property(name=serviceName + "_request",description="Request property for service <" + serviceName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis= serviceName + ":_request")
+                    self.property_registry.add_property(name=serviceName + "_response",description="Response property for service <" + serviceName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis= serviceName + ":_response")
+                    self.register_data_callback(data_name=serviceName + "_request",callback=self.generic_service_callback,isService=True)
+                if service is not None:
+                    if callback is not None:
+                        service.requestProperty = serviceName + "_request"
+                        service.responseProperty= serviceName + "_response"
+                        service.callback = callback
+                    self.services.append(service)
+            else:
+                self.logger.info("No service name provided.")
+        else:
+            self.logger.info("Selected transport protocol <"+protocol+"> not supported for flexNode service.")
+
+
+    def generic_service_callback(self,topic,request):
+        "Generic service callback"
+
+        _service = None
+        _request = None
+        _response = None
+        #1. determine service
+        for service in self.services:
+            if service.name in topic:
+                _service = service
+                #instantiate request
+                req = service.request
+                req.instantiate(json_str=request)
+                _request = req
+                #instantiate response
+                resp = service.response
+                _response = resp
+
+        #execute callback
+        response = _service.callback(_request,_response)
+
+        #publish response
+        self.set_data(data_name=_service.responseProperty, data=response)
+
+
+    def create_client(self, protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,service=None,serviceName='TBD'):
+        """Creates and registers a new service."""
+        _comm_manager = None
+        if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_MQTT or protocol == TRANSPORT_PROTOCOLS.PROTOCOL_REDIS:
+            if serviceName is not None:
+                _client = client(name=serviceName+"_client",logger=self.logger,set_data=self.set_data)
+                # add property to and resolve name
+                if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_MQTT:
+                    self.property_registry.add_property(name=serviceName + "_request",description="Request property for service <" + serviceName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT, mqtt="/" + serviceName + "/_request")
+                    self.property_registry.add_property(name=serviceName + "_response",description="Response property for service <" + serviceName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,mqtt="/" + serviceName + "/_response")
+                    self.register_data_callback(data_name=serviceName + "_response",callback=_client.response_callback, isService=True)
+                elif protocol == TRANSPORT_PROTOCOLS.PROTOCOL_REDIS:
+                    self.property_registry.add_property(name=serviceName + "_request",description="Request property for service <" + serviceName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis=serviceName + ":_request")
+                    self.property_registry.add_property(name=serviceName + "_response",description="Response property for service <" + serviceName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis=serviceName + ":_response")
+                    self.register_data_callback(data_name=serviceName + "_response",callback=_client.response_callback, isService=True)
+                if service is not None:
+                    service.requestProperty = serviceName + "_request"
+                    service.responseProperty = serviceName + "_response"
+                    self.services.append(service)
+
+                    #add client service
+                    _client.service = service
+                    return _client
+            else:
+                self.logger.info("No service name provided.")
+        else:
+            self.logger.info("Selected transport protocol <"+protocol+"> not supported for flexNode service.")
+
+    # --------------------------------------------------------------------------------------
+    # - --------------------------------ACTIONS --------------------------------------------
+    # --------------------------------------------------------------------------------------
+    def create_action_server(self, protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,action=None,actionName='TBD', callback=None):
+        """Creates and registers a new action."""
+        if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_MQTT or protocol == TRANSPORT_PROTOCOLS.PROTOCOL_REDIS:
+            #register service to node
+
+            if actionName is not None:
+                #add property to and resolve name
+                if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_MQTT:
+                    self.property_registry.add_property(name=actionName+"_request",description="Request property for action <"+actionName+">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,mqtt="/"+actionName+"/_request")
+                    self.property_registry.add_property(name=actionName + "_response",description="Response property for action <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT, mqtt="/" + actionName + "/_response")
+                    self.property_registry.add_property(name=actionName + "_feedback",description="Feedback property for action <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,mqtt="/" + actionName + "/_feedback")
+
+                    self.register_data_callback(data_name=actionName+"_request",callback=self.generic_action_callback,isService=True)
+                elif protocol == TRANSPORT_PROTOCOLS.PROTOCOL_REDIS:
+                    self.property_registry.add_property(name=actionName + "_request",description="Request property for action <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis=actionName + ":_request")
+                    self.property_registry.add_property(name=actionName + "_response",description="Response property for action <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis=actionName + ":_response")
+                    self.property_registry.add_property(name=actionName + "_feedback",description="Feedback property for action <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis=actionName + ":_feedback")
+
+                    self.register_data_callback(data_name=actionName + "_request",callback=self.generic_action_callback,isService=True)
+                if action is not None:
+                    if callback is not None:
+                        action.requestProperty = actionName + "_request"
+                        action.responseProperty= actionName + "_response"
+                        action.feedbackProperty = actionName + "_feedback"
+                        action.callback = callback
+                    self.services.append(action)
+            else:
+                self.logger.info("No action name provided.")
+        else:
+            self.logger.info("Selected transport protocol <"+protocol+"> not supported for flexNode action.")
+
+
+    def generic_action_callback(self,topic,request):
+        "Generic service callback"
+
+        _action = None
+        _request = None
+        _response = None
+        _feedback = None
+        #1. determine service
+        for action in self.services:
+            if action.name in topic:
+                _action = action
+                #instantiate request
+                _action.request.instantiate(json_str=request)
+
+        # instantiate the goal_handle with asynchronous communication manager #TOOD: CHECK IF THERE IS A BETTER WAY
+
+        _goal_handle = goal_handle(name=_action.name+"_goal_handle",action=_action,logger=self.logger)
+
+        #execute callback
+        goal_handle_result = _action.callback(_goal_handle)
+
+
+        #publish response
+        self.set_data(data_name=_action.responseProperty, data=goal_handle_result.response)
+
+    def publish_action_feedback(self,goal_handle):
+        self.set_data(data_name=goal_handle.action.feedbackProperty, data=goal_handle.action.feedback)
+
+
+
+    def publish_action_success(self,goal_handle):
+        goal_handle.feedback.status = GOAL_STATUS.SUCCEEDED
+        self.set_data(data_name=goal_handle.action.feedbackProperty, data=goal_handle.action.feedback)
+
+
+    def create_action_client(self, protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,action=None,actionName='TBD'):
+        """Creates and registers a new service."""
+        _comm_manager = None
+        if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_MQTT or protocol == TRANSPORT_PROTOCOLS.PROTOCOL_REDIS:
+            if actionName is not None:
+                _client = ation_client(name=actionName+"_client",logger=self.logger,set_data=self.set_data)
+                # add property to and resolve name
+                if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_MQTT:
+                    self.property_registry.add_property(name=actionName + "_request",description="Request property for service <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT, mqtt="/" + actionName + "/_request")
+                    self.property_registry.add_property(name=actionName + "_feedback",description="Feedback property for service <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,mqtt="/" + actionName + "/_feedback")
+                    self.property_registry.add_property(name=actionName + "_response",description="Response property for service <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,mqtt="/" + actionName + "/_response")
+                    self.register_data_callback(data_name=actionName + "_response",callback=_client.response_callback, isService=True)
+                    self.register_data_callback(data_name=actionName + "_feedback", callback=_client.feedback_callback,isService=True)
+                elif protocol == TRANSPORT_PROTOCOLS.PROTOCOL_REDIS:
+                    self.property_registry.add_property(name=actionName + "_request",description="Request property for service <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis=actionName + ":_request")
+                    self.property_registry.add_property(name=actionName + "_feedback",description="Feedback property for service <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis=actionName + ":_feedback")
+                    self.property_registry.add_property(name=actionName + "_response",description="Response property for service <" + actionName + ">",protocol=TRANSPORT_PROTOCOLS.PROTOCOL_REDIS,redis=actionName + ":_response")
+                    self.register_data_callback(data_name=actionName + "_response",callback=_client.response_callback, isService=True)
+                    self.register_data_callback(data_name=actionName + "_feedback", callback=_client.feedback_callback,isService=True)
+                if action is not None:
+                    action.requestProperty = actionName + "_request"
+                    action.responseProperty = actionName + "_response"
+                    action.feedbackProperty = actionName + "_feedback"
+                    self.services.append(action)
+
+                    #add client service
+                    _client.action = action
+                    return _client
+            else:
+                self.logger.info("No action name provided.")
+        else:
+            self.logger.info("Selected transport protocol <"+protocol+"> not supported for flexNode action.")
+
+    # --------------------------------------------------------------------------------------
+    # - -----------------------------FMI integration ---------------------------------------
+    # --------------------------------------------------------------------------------------
+    def create_fmu_component(self,name='tbd',description="no description provided",stepsize=0.01,fmuPath="/input"):
+        _fmu = None
+        try:
+            #TODO: load all ports automatically!
+            _fmu = FMUNode(name=name,description=description,stepsize=stepsize,fmuPath=fmuPath)
+            self._fmu_list.append(_fmu)
+        except:
+            self.logger.error("Could not create FMU components.")
+
+        return _fmu
+
+    def create_standalone_rt_fmu(self,protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,name='tbd',description="no description provided",stepsize=0.01,fmuPath="/input"):
+        """
+            Generate a real-time standalone FMU (Functional Mock-up Unit).
+
+            Notes:
+                - only ONE real-time FMU can be instantiated per node
+        """
+        _fmu = None
+        try:
+            self._rt_fmu = FMUNode(name=name, description=description, stepsize=stepsize, fmuPath=fmuPath)
+
+            # 1. instantiate timer for auto-triggering
+            _timer = self.create_timer(timer_period=stepsize,callback=self._rt_fmu_dostep_callback)
+            # 2. instantiate properties for all input/outputs
+            for input in self._rt_fmu.getInputs():
+                self._add_generated_property(protocol=protocol,name=input[0],description="Auto-generated property for FMU input <"+input[0]+"> - value reference ["+input[1].__str__()+"]",prefix=self._rt_fmu.name,key=input[0])
+            for output in self._rt_fmu.getOutputs():
+                self._add_generated_property(protocol=protocol,name=output[0],description="Auto-generated property for FMU output <"+output[0]+"> - value reference ["+output[1].__str__()+"]",prefix=self._rt_fmu.name,key=output[0])
+            # 3. expose all parameters to cloud
+
+        except:
+            self.logger.error("Could not create real-time FMU components.")
+
+        return self._rt_fmu
+
+    def _rt_fmu_dostep_callback(self):
+        try:
+
+            # perform doStep function
+            self._rt_fmu.doStep()
+            # expose output ports
+            #TODO:add expose ports
+        except:
+            self.logger.error("Failed to perform the rt_fmu_callback.")
+
+
+    # --------------------------------------------------------------------------------------
+    # - -----------------------------HELPERS ---------------------------------------
+    # --------------------------------------------------------------------------------------
+    def _add_generated_property(self,protocol=TRANSPORT_PROTOCOLS.PROTOCOL_MQTT,name="",description="",prefix=None,key="in"):
+
+        if protocol == TRANSPORT_PROTOCOLS.PROTOCOL_MQTT:
+            if prefix is not None:
+                _key = prefix+"/"+key
+            else:
+                _key = key
+            self.property_registry.add_property(name=name,description=description,protocol=protocol,mqtt=_key)
+        elif protocol == TRANSPORT_PROTOCOLS.PROTOCOL_REDIS:
+            if prefix is not None:
+                _key = prefix+":"+key
+            else:
+                _key = key
+            self.property_registry.add_property(name=name, description=description, protocol=protocol, redis=_key)
+        else:
+            self.logger.info("Selected transport protocol <" + protocol + "> not supported for auto-generated properties.")
+
+    def update_property_endpoint(self,property_name="",endpoint=""):
+        isUpdated = self.property_registry.update_endpoint(name=property_name,endpoint=endpoint)
+        if isUpdated:
+            self.logger.info("Property <"+property_name+"> endpoint updated to: "+endpoint)
+        else:
+            self.logger.warning("Failed to update endpoint for property <"+property_name+"> to: "+endpoint)
+
+    # --------------------------------------------------------------------------------------
+    # - -----------------------------VF integration ---------------------------------------
+    # --------------------------------------------------------------------------------------
+    def loadVF(self,path_to_vf="input/VF.vf",verbose=False):
+        # 1. load VF
+        self.vf = validityFrameManager(name="VFManager", logger=self.logger)
+        self.vf.load(path_to_vf=path_to_vf)
+        # 2. dump VF if verbose
+        if verbose: self.vf.dump()
+        # 3. Expose static parts
+        self._exposeArchitecture()
+        self._exposeATraceabilityGraph()
+        # 4. register runmonitors
+        self._registerRuntimeMonitors()
+
+
+        return self.vf
+
+    def update_vf_monitor(self,monitor_name="",value=0.0):
+        x=1
+        #TODO: update runtime monitor by name
+
+    def _exposeArchitecture(self):
+        _architecture = self.vf.generateSAIfetyArchitecture()
+        _key = self.vf_key + VALIDITY_FRAME_INTEGRATION.ARCHITECTURE
+        self.flexCloud_manager.write(_key, self._encode(_architecture))
+
+    def _exposeATraceabilityGraph(self):
+        _traceabilityGraph = self.vf.generateTraceabilityGraph()
+        _key = self.vf_key + VALIDITY_FRAME_INTEGRATION.TRACEABILITYGRAPH
+        self.flexCloud_manager.write(_key, self._encode(_traceabilityGraph))
+
+    def _registerRuntimeMonitors(self):
+        for monitor in self.vf.flexia_runtime_monitors:
+            self.register_runtime_monitor(monitor=monitor)