MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/pea/pea_opcua_server/pea_opcua_server.py

@@ -0,0 +1,492 @@
+"""Implementation of the PEA opcua server."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import Any
+from opcua import Server, ua
+
+from mtppy.utils.logging import logger
+from mtppy.pea.pea_opcua_server.opcua_options_provider.opcua_options_provider import (
+    OPCUAOptionsProvider,
+)
+from mtppy.pea.pea_opcua_server.marshalling import Marshalling
+from mtppy.part5.communication_object import OPCUACommunicationObject
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.pea.pea_opcua_server.subscription_list import SubscriptionList
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.part4.automation_services.procedure import Procedure
+from mtppy.part4.automation_services.service import Service
+
+
+class PeaOPCUAServer:
+    def __init__(
+        self,
+        opcua_options_provider: OPCUAOptionsProvider,
+        endpoint: str = "opc.tcp://localhost:4840/",
+    ) -> None:
+        """
+        Initializes an OPC UA server for PEA.
+
+        Args:
+            opcua_options_provider: Instance of an OPCUAOptionsProvider.
+            endpoint: Endpoint of the OPC UA server. If not specified, opc.tcp://localhost:4840/ is used.
+        """
+        self.endpoint = endpoint
+        self.opcua_server = None
+        self.opcua_ns = None
+        self.opcua_ns_index = None
+        self.opcua_options_provider = opcua_options_provider
+        self.subscription_list = SubscriptionList()
+
+    def init_opcua_server(self) -> None:
+        """Initializes an OPC UA server."""
+        logger.opcua(f"Initializing PEA OPC UA server: {self.endpoint}")
+        self.opcua_server = Server()
+        self.opcua_server.set_endpoint(self.endpoint)
+
+        # set all possible endpoint policies for clients to connect through
+        self.opcua_server.set_security_policy(
+            [
+                ua.SecurityPolicyType.NoSecurity,
+                #                ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt,
+                #                ua.SecurityPolicyType.Basic256Sha256_Sign,
+            ]
+        )
+
+        # init our own namespace
+        namespace_uri = self.opcua_options_provider.get_default_namespace_uri()
+        self.opcua_ns_index = self.opcua_server.register_namespace(namespace_uri)
+
+    def _get_opcua_server(self):
+        """
+        Gets OPC UA server instance object.
+
+        Returns:
+            The OPC UA server instance.
+        """
+        return self.opcua_server
+
+    def _get_opcua_ns_index(self) -> int:
+        """
+        Gets OPC UA server namespace index of default namespace uri.
+
+        Returns:
+            The OPC UA server namespace index.
+        """
+        return self.opcua_ns_index
+
+    def get_node_part_ns_index(self) -> str:
+        """Get OPC UA server namespace index of default namespace uri.
+
+        Returns:
+            The OPC UA server namespace index as a string.
+        """
+        return f"ns={self.opcua_ns_index};"
+
+    def _get_opcua_ns_uri(self):
+        """Get OPC UA server default namespace.
+
+        Returns:
+            The OPC UA server default namespace.
+        """
+        return self.opcua_options_provider.get_default_namespace_uri()
+
+    def run_opcua_server(self, data_assemblies, service_set):
+        """Start the OPC UA server instance."""
+        self.opcua_server.start()
+        self._build_opcua_server(data_assemblies, service_set)
+        self._start_subscription()
+
+    def _build_opcua_server(self, data_assemblies, service_set):
+        """Create an OPC UA server instance adding required nodes according to
+        defined DataAssemblies."""
+        logger.opcua(f"Adding OPC UA nodes")
+        server = self.opcua_server.get_objects_node()
+
+        # Iterate over DataAssemblies
+        root_node_data_assemblies_folder = server.add_folder(
+            f"{self.get_node_part_ns_index()}s=data_assemblies", "data_assemblies"
+        )
+        for data_assembly_instance in data_assemblies.values():
+            logger.opcua(f"- DataAssembly {data_assembly_instance.tag_name}")
+            self._create_opcua_objects_for_data_assembly(
+                data_assembly_instance, root_node_data_assemblies_folder
+            )
+
+        # Iterate over services
+        root_node_services_folder = server.add_folder(
+            f"{self.get_node_part_ns_index()}s=services", "services"
+        )
+        for service_instance in service_set.values():
+            logger.opcua(f"- Service {service_instance.name}")
+            self._create_opcua_objects_for_service(
+                service_instance, root_node_services_folder
+            )
+
+    def _create_opcua_objects_for_service(self, service_instance: Service, root_node):
+
+        root_node_service_folder = root_node.add_folder(
+            f"{self.get_node_part_ns_index()}s=service.{service_instance.name}",
+            service_instance.name,
+        )
+
+        logger.opcua(f"- Service Control {service_instance.service_control.tag_name}")
+        self._create_opcua_objects_for_data_assembly(
+            service_instance.service_control, root_node_service_folder
+        )
+
+        if service_instance.configuration_parameters:
+            root_node_service_config_param_folder = root_node_service_folder.add_folder(
+                f"{self.get_node_part_ns_index()}s=service.{service_instance.name}.configuration_parameters",
+                "configuration_parameters",
+            )
+            for (
+                configuration_parameter
+            ) in service_instance.configuration_parameters.values():
+                logger.opcua(
+                    f"- Service Configuration Parameter {configuration_parameter.tag_name}"
+                )
+                self._create_opcua_objects_for_data_assembly(
+                    configuration_parameter, root_node_service_config_param_folder
+                )
+
+        root_node_service_procedures_folder = root_node_service_folder.add_folder(
+            f"{self.get_node_part_ns_index()}s=service.{service_instance.name}.procedures",
+            "procedures",
+        )
+        for procedure in service_instance._get_procedures().values():
+            logger.opcua(f"- Service Procedure {procedure.name}")
+            self._create_opcua_objects_for_procedure(
+                procedure, root_node_service_procedures_folder, service_instance.name
+            )
+
+    def _create_opcua_objects_for_procedure(
+        self, procedure: Procedure, root_node, service_name: str
+    ):
+
+        root_node_procedure_folder = root_node.add_folder(
+            f"{self.get_node_part_ns_index()}s=service.{service_name}.procedures.{procedure.name}",
+            procedure.name,
+        )
+
+        logger.opcua(f"- Procedure {procedure.name}")
+        self._create_opcua_objects_for_data_assembly(
+            procedure.procedure_health_view, root_node_procedure_folder
+        )
+
+        if procedure.procedure_parameters:
+            root_node_service_proc_param_folder = root_node_procedure_folder.add_folder(
+                f"{self.get_node_part_ns_index()}s=service.{service_name}.procedures.{procedure.name}.procedure_parameters",
+                "procedure_parameters",
+            )
+            for procedure_parameter in procedure.procedure_parameters.values():
+                logger.opcua(
+                    f"- Procedure ProcedureParameter {procedure_parameter.tag_name}"
+                )
+                self._create_opcua_objects_for_data_assembly(
+                    procedure_parameter, root_node_service_proc_param_folder
+                )
+
+        if procedure.process_value_ins:
+            root_node_service_process_value_ins_folder = root_node_procedure_folder.add_folder(
+                f"{self.get_node_part_ns_index()}s=service.{service_name}.procedures.{procedure.name}.process_value_ins",
+                "process_value_ins",
+            )
+            for process_value_in in procedure.process_value_ins.values():
+                logger.opcua(f"- Procedure ProcessValueIn {process_value_in.tag_name}")
+                self._create_opcua_objects_for_data_assembly(
+                    process_value_in, root_node_service_process_value_ins_folder
+                )
+
+        if procedure.process_value_outs:
+            root_node_service_process_value_outs_folder = root_node_procedure_folder.add_folder(
+                f"{self.get_node_part_ns_index()}s=service.{service_name}.procedures.{procedure.name}.process_value_outs",
+                "process_value_outs",
+            )
+            for process_value_out in procedure.process_value_outs.values():
+                logger.opcua(
+                    f"- Procedure ProcessValueOut {process_value_out.tag_name}"
+                )
+                self._create_opcua_objects_for_data_assembly(
+                    process_value_out, root_node_service_process_value_outs_folder
+                )
+        if procedure.report_values:
+            root_node_service_report_values_folder = root_node_procedure_folder.add_folder(
+                f"{self.get_node_part_ns_index()}s=service.{service_name}.procedures.{procedure.name}.report_values",
+                "report_values",
+            )
+            for report_value in procedure.report_values.values():
+                logger.opcua(f"- Procedure ReportValue {report_value.tag_name}")
+                self._create_opcua_objects_for_data_assembly(
+                    report_value, root_node_service_report_values_folder
+                )
+
+    def node_exists(self, nodeid):
+        try:
+            node = self.opcua_server.get_node(nodeid)
+            _ = node.get_browse_name()  # Triggers error if node doesn't exist
+            return True
+        except ua.uaerrors._auto.BadNodeIdUnknown:
+            return False
+
+    def is_folder(self, nodeid):
+        try:
+            # Get the NodeClass of the node
+            node = self.opcua_server.get_node(nodeid)
+            node_class = node.get_node_class()
+            if node_class == ua.NodeClass.Object:
+                # Check if the ObjectType is FolderType
+                object_type = node.get_type_definition()
+                if object_type.Identifier == ua.ObjectIds.FolderType:
+                    return True
+            return False
+        except Exception as e:
+            print(f"Error checking if node is a folder: {e}")
+            return False
+
+    # root_node_data_assembly = root_node.add_folder( f"{self.get_node_part_ns_index()}s={tag_name}", tag_name)
+    def add_folder_if_not_exists(self, root_node, tag_name):
+        # Construct the NodeId for the folder
+        parent_identifier = root_node.nodeid.Identifier
+        folder_identifier = (
+            f"{parent_identifier}.{tag_name}"
+            if isinstance(parent_identifier, str)
+            else tag_name
+        )
+        node_id = f"{self.get_node_part_ns_index()}s={folder_identifier}"
+        children = root_node.get_children()
+
+        # Check if a child with the desired browse name already exists
+        for child in children:
+            if (
+                child.get_browse_name().Name == tag_name
+                and child.nodeid.to_string() == node_id
+            ):
+                logger.opcua(f"Folder '{tag_name}' exists with NodeId: {child.nodeid}")
+                return child  # Return the existing node
+
+        # If the folder does not exist, create it
+        if self.node_exists(node_id) and self.is_folder(node_id):
+            node = self.opcua_server.get_node(node_id)
+            root_node.add_reference(node.nodeid, ua.ObjectIds.Organizes)
+            logger.opcua(
+                f"Folder '{node.get_browse_name().Name}' exists with NodeId: {node.nodeid}"
+            )
+            return node
+        else:
+            new_folder = root_node.add_folder(node_id, tag_name)
+            logger.opcua(
+                f"Folder '{tag_name}' created with NodeId: {new_folder.nodeid}"
+            )
+            return new_folder
+
+    def _create_opcua_objects_for_data_assembly(
+        self, data_assembly: DataAssembly, root_node
+    ):
+        """Iterate over DataAssemblies to create OPC UA objects.
+
+        Args:
+            data_assembly: DataAssembly.
+            root_node: Parent OPC UA node where the DataAssembly shall be attached.
+        """
+        # create new root node for DataAssembly
+        if hasattr(data_assembly, "tag_name"):
+            tag_name = data_assembly.tag_name
+        elif hasattr(data_assembly, "CLASS_DATA_ITEMS"):
+            tag_name = data_assembly["TagName"]
+
+        try:
+            root_node_data_assembly = self.add_folder_if_not_exists(root_node, tag_name)
+
+            base_functions = [
+                "op_mode",
+                "src_mode",
+                "os_level",
+                "wqc",
+                "vqc",
+                "service_op_mode",
+                "service_src_mode",
+                "service_operator_interaction",
+            ]
+
+            if hasattr(data_assembly, "_data_items"):
+                self._create_opcua_nodes_for_data_items(
+                    data_assembly._data_items,
+                    tag_name,
+                    root_node_data_assembly,
+                )
+
+            for base_function_name in base_functions:
+                if not hasattr(data_assembly, base_function_name):
+                    continue
+                base_function_root_node = self.add_folder_if_not_exists(
+                    root_node_data_assembly, base_function_name
+                )
+                base_function = eval(f"data_assembly.{base_function_name}")
+                logger.info(
+                    f"Creating opcua nodes for {base_function_name}, type{type(base_function)}"
+                )
+                self._create_opcua_nodes_for_data_items(
+                    base_function._data_items,  # TBD: brutal, mitten rein greifen, am offenen Herzen
+                    tag_name,
+                    base_function_root_node,
+                )
+        except ua.UaStatusCodeError as e:
+            msg = f"Error creating DataAssembly {tag_name}: {e}"
+            logger.warning(msg)
+
+    def add_node_or_reference(
+        self,
+        data_item: DataAssembly,
+        parent_node: ua.NodeId,
+        node_id: str,
+        browse_name: str,
+        init_value: Any,
+        variant_type: ua.VariantType,
+        reference_type: int = ua.ObjectIds.Organizes,
+    ):
+        """
+        Adds a node to the namespace if it does not exist. If the node already exists,
+        it creates a reference to the existing node.
+
+        Arguments:
+            parent_node: The parent node under which the new node or reference will be added.
+            node_id: The NodeId of the node to add or reference.
+            browse_name: The BrowseName of the node to add or reference.
+            variant_type: The type of the variable node
+            reference_type: The type of reference to create if the node already exists (default is Organizes).
+
+        Retuns
+            The created or referenced node.
+        """
+        # Check if the node already exists in the namespace
+        existing_node = next(
+            (
+                child
+                for child in parent_node.get_children()
+                if child.nodeid.to_string() == node_id
+            ),
+            None,
+        )
+
+        if existing_node is None and self.node_exists(node_id):
+            existing_node = self.opcua_server.get_node(node_id)
+
+        if existing_node:
+            # Node already exists, create a reference to it
+            parent_node.add_reference(existing_node.nodeid, reference_type)
+            logger.opcua(f"Reference added to existing node: {browse_name}")
+            return existing_node
+        else:
+            # Node does not exist, create it
+            opcua_node_obj = parent_node.add_variable(
+                node_id,
+                browse_name,
+                init_value,
+                varianttype=variant_type,
+            )
+            opcua_comm_obj = OPCUACommunicationObject(
+                opcua_node_obj, node_id=opcua_node_obj
+            )
+            data_item.attach_communication_object(opcua_comm_obj)
+            if (data_item.access is MTPAccess.ReadWriteAccess) or (
+                data_item.access is MTPAccess.WriteAccess
+            ):
+                opcua_node_obj.set_writable(True)
+                self.subscription_list.append(opcua_node_obj, data_item.ext_wrt_cb)
+            else:
+                opcua_node_obj.set_writable(False)
+            logger.opcua(f"Node created: {browse_name}")
+            return opcua_node_obj
+
+    def _create_opcua_nodes_for_data_items(
+        self, data_items, parent_name: str, root_node
+    ):
+        """
+        Iterate over DataItems of DataAssembly to create corresponding OPC UA nodes.
+
+        Args:
+            data_items: Elements of DataItem that an OPC UA node is to created for.
+            parent_name: Name of the DataItem parent, should be TagName of DataAssembly.
+            root_node: Parent OPC UA node where the Data is to add to.
+
+        """
+        logger.debug(f"Creating OPC UA nodes for: {parent_name}")
+
+        for data_item in data_items.values():
+            data_item_node_id = (
+                self.get_node_part_ns_index()
+                + self.opcua_options_provider.generate_node_id(
+                    data_assembly_name=parent_name, data_item_name=data_item.name
+                )
+            )
+
+            # We attach communication objects to be able to write values on opcua server on DataItems change
+            opcua_type = self._map_data_type(data_item.w3c_xml_data_type)
+
+            _ = self.add_node_or_reference(
+                data_item=data_item,
+                parent_node=root_node,
+                node_id=data_item_node_id,
+                browse_name=data_item.name,
+                init_value=data_item.init_value,
+                variant_type=opcua_type,
+            )
+            #            opcua_node_obj = root_node.add_variable(
+            #                data_item_node_id,
+            #                data_item.name,
+            #                data_item.init_value,
+            #                varianttype=opcua_type,
+            #            )
+            #            opcua_node_obj.set_attribute(
+            #                ua.AttributeIds.DisplayName,
+            #                ua.DataValue(ua.LocalizedText(data_item.name)),
+            #            )
+            #            opcua_node_obj.set_attribute(
+            #                ua.AttributeIds.Description,
+            #                ua.DataValue(ua.LocalizedText(data_item.description)),
+            #            )
+
+            logger.opcua(
+                f"OPCUA Node: {data_item_node_id}, Name: {data_item.name}, Value: {data_item.init_value}"
+            )
+
+    @staticmethod
+    def _map_data_type(w3c_xml_data_type):
+        """
+        Translate a python data type to a suitable OPC UA data type.
+
+        Args:
+            w3c_xml_data_type: W3cXmlDataType.
+
+        Returns:
+            OPC UA data type
+        """
+        if not isinstance(w3c_xml_data_type, W3cXmlDataTypes):
+            raise TypeError(
+                f"Invalid argument: {w3c_xml_data_type} is not a valid W3cXmlDataType"
+            )
+
+        opcua_variant = w3c_xml_data_type.opcua_variant
+        if opcua_variant is None:
+            raise TypeError(
+                f"Data type {w3c_xml_data_type} is not supported for OPC UA mapping"
+            )
+        return opcua_variant
+
+    def _start_subscription(self):
+        """
+        Subscribes to defined OPC UA nodes.
+        :return:
+        """
+        handler = Marshalling()
+        handler.import_subscription_list(self.subscription_list)
+        node_ids = self.subscription_list.get_nodeid_list()
+        if not node_ids:
+            return
+        sub = self.opcua_server.create_subscription(500, handler)
+        sub.subscribe_data_change(node_ids)

mtppy/pea/pea_opcua_server/subscription_list.py

@@ -0,0 +1,55 @@
+"""Subscription list that contains all OPC UA nodes that a PEA must subscribe to."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+
+class SubscriptionList:
+    """A class to manage subscriptions to OPC UA nodes.
+
+    This class maintains a list of OPC UA nodes that a PEA (Process Execution Agent)
+    must subscribe to. It provides methods to add subscriptions, retrieve node IDs,
+    and obtain callback functions for value changes.
+    """
+
+    def __init__(self):
+        """Initialize instance of Subscription List with empty list."""
+        self.sub_list = {}
+
+    def append(self, node_id, cb_value_change):
+        """Add a subscription entity.
+
+        Args:
+            node_id: OPC UA node.
+            cb_value_change: Callback function for a value change.
+        """
+        identifier = node_id.nodeid.Identifier
+        self.sub_list[identifier] = {"node_id": node_id, "callback": cb_value_change}
+
+    def get_nodeid_list(self):
+        """Extract a list of node ids in the subscription list.
+
+        Returns:
+            List of node ids.
+        """
+        if len(self.sub_list) == 0:
+            return None
+        else:
+            node_id_list = []
+            for node_id in self.sub_list.values():
+                node_id_list.append(node_id["node_id"])
+            return node_id_list
+
+    def get_callback(self, node_id):
+        """Get a callback function for a specific OPC UA node.
+
+        Args:
+            node_id: OPC UA node id
+        """
+        identifier = node_id.nodeid.Identifier
+        if identifier in self.sub_list.keys():
+            return self.sub_list[identifier]["callback"]
+        else:
+            return None

mtppy/pea/pea_test.py

@@ -0,0 +1,59 @@
+"""Tests for PEA component registration."""
+
+# ruff: noqa: S101
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+import pytest
+
+from mtppy.part3.data_assembly_set.indicator_elements.views.bin_view import BinView
+from mtppy.part6.alarm_set.alarm import Alarm
+from mtppy.pea.pea import PEA
+
+
+def build_alarm(tag_name: str = "LevelHigh.Alarm") -> Alarm:
+    """Build an alarm suitable for PEA registration tests."""
+    trigger_assembly = BinView("LevelHigh")
+    return Alarm(
+        tag_name=tag_name,
+        data_assembly=trigger_assembly,
+        trigger=trigger_assembly.get_item(BinView.V_),
+        trigger_value=True,
+        message="Level is too high.",
+        ack_required=True,
+        severity=500,
+    )
+
+
+def test_add_alarm_registers_alarm_by_tag_name() -> None:
+    """PEA exposes registered alarms through its alarm dictionary."""
+    pea = PEA()
+    alarm = build_alarm()
+
+    pea.add_alarm(alarm)
+
+    assert pea.alarms == {alarm.tag_name: alarm}
+
+
+def test_add_alarm_rejects_wrong_type() -> None:
+    """PEA rejects arbitrary objects in the alarm registry."""
+    pea = PEA()
+
+    with pytest.raises(TypeError, match="Alarm"):
+        pea.add_alarm(object())  # type: ignore[arg-type]
+
+
+def test_add_alarm_rejects_duplicate_tag_name() -> None:
+    """A later alarm must not silently replace an existing alarm."""
+    pea = PEA()
+    first = build_alarm()
+    duplicate = build_alarm()
+    pea.add_alarm(first)
+
+    with pytest.raises(ValueError, match="already registered"):
+        pea.add_alarm(duplicate)
+
+    assert pea.alarms[first.tag_name] is first